home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / cg.lha / cg / m2c / Tree.c < prev    next >
C/C++ Source or Header  |  1992-11-24  |  106KB  |  4,104 lines
  1. #include "SYSTEM_.h"
  2.  
  3. #ifndef DEFINITION_System
  4. #include "System.h"
  5. #endif
  6.  
  7. #ifndef DEFINITION_General
  8. #include "General.h"
  9. #endif
  10.  
  11. #ifndef DEFINITION_Memory
  12. #include "Memory.h"
  13. #endif
  14.  
  15. #ifndef DEFINITION_DynArray
  16. #include "DynArray.h"
  17. #endif
  18.  
  19. #ifndef DEFINITION_IO
  20. #include "IO.h"
  21. #endif
  22.  
  23. #ifndef DEFINITION_Layout
  24. #include "Layout.h"
  25. #endif
  26.  
  27. #ifndef DEFINITION_StringMem
  28. #include "StringMem.h"
  29. #endif
  30.  
  31. #ifndef DEFINITION_Strings
  32. #include "Strings.h"
  33. #endif
  34.  
  35. #ifndef DEFINITION_Idents
  36. #include "Idents.h"
  37. #endif
  38.  
  39. #ifndef DEFINITION_Texts
  40. #include "Texts.h"
  41. #endif
  42.  
  43. #ifndef DEFINITION_Sets
  44. #include "Sets.h"
  45. #endif
  46.  
  47. #ifndef DEFINITION_Positions
  48. #include "Positions.h"
  49. #endif
  50.  
  51. #ifndef DEFINITION_DynArray
  52. #include "DynArray.h"
  53. #endif
  54.  
  55. #ifndef DEFINITION_IO
  56. #include "IO.h"
  57. #endif
  58.  
  59. #ifndef DEFINITION_Strings
  60. #include "Strings.h"
  61. #endif
  62.  
  63. #ifndef DEFINITION_StringMem
  64. #include "StringMem.h"
  65. #endif
  66.  
  67. #ifndef DEFINITION_Idents
  68. #include "Idents.h"
  69. #endif
  70.  
  71. #ifndef DEFINITION_Texts
  72. #include "Texts.h"
  73. #endif
  74.  
  75. #ifndef DEFINITION_Sets
  76. #include "Sets.h"
  77. #endif
  78.  
  79. #ifndef DEFINITION_Relations
  80. #include "Relations.h"
  81. #endif
  82.  
  83. #ifndef DEFINITION_Positions
  84. #include "Positions.h"
  85. #endif
  86.  
  87. #ifndef DEFINITION_Relations
  88. #include "Relations.h"
  89. #endif
  90.  
  91. #ifndef DEFINITION_Errors
  92. #include "Errors.h"
  93. #endif
  94.  
  95. #ifndef DEFINITION_Tree
  96. #include "Tree.h"
  97. #endif
  98.  
  99. CARDINAL Tree_ErrorCount;
  100. INTEGER Tree_ClassCount;
  101. BITSET Tree_GrammarClass;
  102. SHORTCARD Tree_MaxVisit;
  103. Idents_tIdent Tree_SubUnit, Tree_ViewName, Tree_iPosition, Tree_itPosition, Tree_iInteger, Tree_iMain, Tree_iModule, Tree_itTree, Tree_iNoTree;
  104. Strings_tString Tree_ModuleName;
  105. Sets_tSet Tree_TypeNames, Tree_MaxSet;
  106. Sets_tSet Tree_Options;
  107. IO_tFile Tree_f;
  108. struct Tree_4 Tree_SourceFile;
  109. BITSET Tree_NoCodeAttr, Tree_NoCodeClass;
  110. Tree_tTree Tree_nNoAction, Tree_nNoAttribute, Tree_nNoClass, Tree_nNoDecl, Tree_nNoDesignator, Tree_nNoLayout, Tree_nNoModule, Tree_nNoName, Tree_nNoPrec, Tree_nNoProp;
  111. Tree_tTree Tree_TreeRoot;
  112. LONGCARD Tree_HeapUsed;
  113. ADDRESS Tree_yyPoolFreePtr, Tree_yyPoolMaxPtr;
  114. struct Tree_57 Tree_yyNodeSize;
  115. PROC Tree_yyExit;
  116.  
  117. static struct S_2 {
  118.     Tree_tTree A[1000000 + 1];
  119. } *IdentToClassPtr;
  120. static LONGINT IdentToClassSize;
  121. static Idents_tIdent sIdentToClassSize;
  122. static Sets_tSet DummySet;
  123. static Relations_tRelation DummyRelation;
  124. #define yyBlockSize    20480
  125. typedef struct S_1 *yytBlockPtr;
  126. typedef struct S_1 {
  127.     struct S_3 {
  128.         CHAR A[yyBlockSize - 1 + 1];
  129.     } yyBlock;
  130.     yytBlockPtr yySuccessor;
  131. } yytBlock;
  132. static yytBlockPtr yyBlockList;
  133. static SHORTCARD yyMaxSize, yyi;
  134. static struct S_4 {
  135.     SHORTCARD A[129 + 1];
  136. } yyTypeRange;
  137. typedef Tree_tTree *yyPtrtTree;
  138. static IO_tFile yyf;
  139. static SHORTCARD yyLabel;
  140. static SHORTCARD yyKind;
  141. static CHAR yyc;
  142. static Strings_tString yys;
  143. static void yyWriteNl ARGS(());
  144. static void yyWriteSelector ARGS((CHAR yys[], LONGCARD ));
  145. static void yyWriteHex ARGS((BYTE yyx[], LONGCARD ));
  146. static void yyWriteAdr ARGS((Tree_tTree yyt));
  147. static void yWriteNodeClass ARGS((Tree_tTree yyt));
  148. static void yWriteNodeAttrOrAction ARGS((Tree_tTree yyt));
  149. static void yWriteNodeChild ARGS((Tree_tTree yyt));
  150. static void yWriteNodeAttribute ARGS((Tree_tTree yyt));
  151. static void yWriteNodeActionPart ARGS((Tree_tTree yyt));
  152. static void yWriteNodeCodes ARGS((Tree_tTree yyt));
  153. static void yWriteNodeDesignator ARGS((Tree_tTree yyt));
  154. static void yWriteNodeIdent ARGS((Tree_tTree yyt));
  155. static void yWriteNodeRemote ARGS((Tree_tTree yyt));
  156. static void yWriteNodeAny ARGS((Tree_tTree yyt));
  157. static void yWriteNodeAnys ARGS((Tree_tTree yyt));
  158. static void yWriteNodeLayoutAny ARGS((Tree_tTree yyt));
  159. static void yWriteNodeName ARGS((Tree_tTree yyt));
  160. static void yWriteNodeAg ARGS((Tree_tTree yyt));
  161. static void yWriteNodePrec ARGS((Tree_tTree yyt));
  162. static void yWriteNodeLeftAssoc ARGS((Tree_tTree yyt));
  163. static void yWriteNodeRightAssoc ARGS((Tree_tTree yyt));
  164. static void yWriteNodeNonAssoc ARGS((Tree_tTree yyt));
  165. static void yWriteNodeAction ARGS((Tree_tTree yyt));
  166. static void yWriteNodeAssign ARGS((Tree_tTree yyt));
  167. static void yWriteNodeCopy ARGS((Tree_tTree yyt));
  168. static void yWriteNodeTargetCode ARGS((Tree_tTree yyt));
  169. static void yWriteNodeOrder ARGS((Tree_tTree yyt));
  170. static void yWriteNodeCheck ARGS((Tree_tTree yyt));
  171. static void yWriteNodeModule ARGS((Tree_tTree yyt));
  172. static void yWriteNodeProp ARGS((Tree_tTree yyt));
  173. static void yWriteNodeSelect ARGS((Tree_tTree yyt));
  174. static void yWriteNodeDecl ARGS((Tree_tTree yyt));
  175. #define yyNil    ((CHAR)'\374')
  176. #define yyNoLabel    ((CHAR)'\375')
  177. #define yyLabelDef    ((CHAR)'\376')
  178. #define yyLabelUse    ((CHAR)'\377')
  179. #define yyyWrite    1
  180. #define yyyRead    2
  181. #define yyyQuit    3
  182. static struct S_7 {
  183.     CHAR A[31 + 1];
  184. } yyString;
  185. static INTEGER yyLength;
  186. static CHAR yyCh;
  187. static INTEGER yyState;
  188. static BOOLEAN yyyIsEqual ARGS((CHAR yya[], LONGCARD ));
  189. static void xxExit ARGS(());
  190.  
  191.  
  192. void Tree_InitIdentifyClass
  193. # ifdef __STDC__
  194. (Tree_tTree t)
  195. # else
  196. (t)
  197. Tree_tTree t;
  198. # endif
  199. {
  200.   INTEGER i;
  201.  
  202.   IdentToClassSize = Idents_MaxIdent() + 1;
  203.   sIdentToClassSize = IdentToClassSize;
  204.   DynArray_MakeArray((ADDRESS *)&IdentToClassPtr, &IdentToClassSize, (LONGINT)sizeof(Tree_tTree));
  205.   {
  206.     LONGINT B_1 = 0, B_2 = IdentToClassSize - 1;
  207.  
  208.     if (B_1 <= B_2)
  209.       for (i = B_1;; i += 1) {
  210.         IdentToClassPtr->A[i] = Tree_NoTree;
  211.         if (i >= B_2) break;
  212.       }
  213.   }
  214.   Tree_ForallClasses(t, (Tree_ProcOfT)Tree_InitIdentifyClass2);
  215. }
  216.  
  217. void Tree_InitIdentifyClass2
  218. # ifdef __STDC__
  219. (Tree_tTree t)
  220. # else
  221. (t)
  222. Tree_tTree t;
  223. # endif
  224. {
  225.   IdentToClassPtr->A[t->U_1.V_5.Class.Name] = t;
  226. }
  227.  
  228. Tree_tTree Tree_IdentifyClass
  229. # ifdef __STDC__
  230. (Tree_tTree t, Idents_tIdent Ident)
  231. # else
  232. (t, Ident)
  233. Tree_tTree t;
  234. Idents_tIdent Ident;
  235. # endif
  236. {
  237.   if (Ident < sIdentToClassSize) {
  238.     return IdentToClassPtr->A[Ident];
  239.   }
  240.   return Tree_NoTree;
  241. }
  242.  
  243. Tree_tTree Tree_IdentifyAttribute
  244. # ifdef __STDC__
  245. (Tree_tTree t, Idents_tIdent Ident)
  246. # else
  247. (t, Ident)
  248. Tree_tTree t;
  249. Idents_tIdent Ident;
  250. # endif
  251. {
  252.   Tree_tTree attribute;
  253.  
  254.   for (;;) {
  255.     switch (t->U_1.V_1.Kind) {
  256.     case Tree_Class:;
  257.       attribute = Tree_IdentifyAttribute(t->U_1.V_5.Class.BaseClass, Ident);
  258.       if (attribute != Tree_NoTree) {
  259.         return attribute;
  260.       }
  261.       t = t->U_1.V_5.Class.Attributes;
  262.       break;
  263.     case Tree_Child:;
  264.       if (t->U_1.V_9.Child.Name == Ident) {
  265.         return t;
  266.       }
  267.       t = t->U_1.V_9.Child.Next;
  268.       break;
  269.     case Tree_Attribute:;
  270.       if (t->U_1.V_10.Attribute.Name == Ident) {
  271.         return t;
  272.       }
  273.       t = t->U_1.V_10.Attribute.Next;
  274.       break;
  275.     case Tree_ActionPart:;
  276.       t = t->U_1.V_11.ActionPart.Next;
  277.       break;
  278.     default :
  279.       return Tree_NoTree;
  280.       break;
  281.     }
  282.   } EXIT_1:;
  283. }
  284.  
  285. void Tree_ForallClasses
  286. # ifdef __STDC__
  287. (Tree_tTree t, Tree_ProcOfT Proc)
  288. # else
  289. (t, Proc)
  290. Tree_tTree t;
  291. Tree_ProcOfT Proc;
  292. # endif
  293. {
  294.   while (t->U_1.V_1.Kind == Tree_Class) {
  295.     (*Proc)(t);
  296.     Tree_ForallClasses(t->U_1.V_5.Class.Extensions, Proc);
  297.     t = t->U_1.V_5.Class.Next;
  298.   }
  299. }
  300.  
  301. void Tree_ForallAttributes
  302. # ifdef __STDC__
  303. (Tree_tTree t, Tree_ProcOfT Proc)
  304. # else
  305. (t, Proc)
  306. Tree_tTree t;
  307. Tree_ProcOfT Proc;
  308. # endif
  309. {
  310.   for (;;) {
  311.     switch (t->U_1.V_1.Kind) {
  312.     case Tree_Class:;
  313.       Tree_ForallAttributes(t->U_1.V_5.Class.BaseClass, Proc);
  314.       t = t->U_1.V_5.Class.Attributes;
  315.       break;
  316.     case Tree_Child:;
  317.       (*Proc)(t);
  318.       t = t->U_1.V_9.Child.Next;
  319.       break;
  320.     case Tree_Attribute:;
  321.       (*Proc)(t);
  322.       t = t->U_1.V_10.Attribute.Next;
  323.       break;
  324.     case Tree_ActionPart:;
  325.       (*Proc)(t);
  326.       t = t->U_1.V_11.ActionPart.Next;
  327.       break;
  328.     default :
  329.       return;
  330.       break;
  331.     }
  332.   } EXIT_2:;
  333. }
  334.  
  335. void Tree_Error
  336. # ifdef __STDC__
  337. (INTEGER ErrorCode, Positions_tPosition Pos)
  338. # else
  339. (ErrorCode, Pos)
  340. INTEGER ErrorCode;
  341. Positions_tPosition Pos;
  342. # endif
  343. {
  344.   Errors_ErrorMessage((LONGCARD)ErrorCode, (LONGCARD)Errors_Error, Pos);
  345.   INC(Tree_ErrorCount);
  346. }
  347.  
  348. void Tree_Warning
  349. # ifdef __STDC__
  350. (INTEGER ErrorCode, Positions_tPosition Pos)
  351. # else
  352. (ErrorCode, Pos)
  353. INTEGER ErrorCode;
  354. Positions_tPosition Pos;
  355. # endif
  356. {
  357.   Errors_ErrorMessage((LONGCARD)ErrorCode, (LONGCARD)Errors_Warning, Pos);
  358. }
  359.  
  360. void Tree_Information
  361. # ifdef __STDC__
  362. (INTEGER ErrorCode, Positions_tPosition Pos)
  363. # else
  364. (ErrorCode, Pos)
  365. INTEGER ErrorCode;
  366. Positions_tPosition Pos;
  367. # endif
  368. {
  369.   Errors_ErrorMessage((LONGCARD)ErrorCode, (LONGCARD)Errors_Information, Pos);
  370. }
  371.  
  372. void Tree_ErrorI
  373. # ifdef __STDC__
  374. (INTEGER ErrorCode, Positions_tPosition Pos, INTEGER iClass, ADDRESS iPtr)
  375. # else
  376. (ErrorCode, Pos, iClass, iPtr)
  377. INTEGER ErrorCode;
  378. Positions_tPosition Pos;
  379. INTEGER iClass;
  380. ADDRESS iPtr;
  381. # endif
  382. {
  383.   Errors_ErrorMessageI((LONGCARD)ErrorCode, (LONGCARD)Errors_Error, Pos, (LONGCARD)iClass, iPtr);
  384.   INC(Tree_ErrorCount);
  385. }
  386.  
  387. void Tree_WarningI
  388. # ifdef __STDC__
  389. (INTEGER ErrorCode, Positions_tPosition Pos, INTEGER iClass, ADDRESS iPtr)
  390. # else
  391. (ErrorCode, Pos, iClass, iPtr)
  392. INTEGER ErrorCode;
  393. Positions_tPosition Pos;
  394. INTEGER iClass;
  395. ADDRESS iPtr;
  396. # endif
  397. {
  398.   Errors_ErrorMessageI((LONGCARD)ErrorCode, (LONGCARD)Errors_Warning, Pos, (LONGCARD)iClass, iPtr);
  399. }
  400.  
  401. void Tree_InformationI
  402. # ifdef __STDC__
  403. (INTEGER ErrorCode, Positions_tPosition Pos, INTEGER iClass, ADDRESS iPtr)
  404. # else
  405. (ErrorCode, Pos, iClass, iPtr)
  406. INTEGER ErrorCode;
  407. Positions_tPosition Pos;
  408. INTEGER iClass;
  409. ADDRESS iPtr;
  410. # endif
  411. {
  412.   Errors_ErrorMessageI((LONGCARD)ErrorCode, (LONGCARD)Errors_Information, Pos, (LONGCARD)iClass, iPtr);
  413. }
  414.  
  415. void Tree_WI
  416. # ifdef __STDC__
  417. (Idents_tIdent i)
  418. # else
  419. (i)
  420. Idents_tIdent i;
  421. # endif
  422. {
  423.   Idents_WriteIdent(Tree_f, i);
  424. }
  425.  
  426. void Tree_WE
  427. # ifdef __STDC__
  428. (Idents_tIdent i)
  429. # else
  430. (i)
  431. Idents_tIdent i;
  432. # endif
  433. {
  434.   Strings_tString s;
  435.   CHAR Ch;
  436.   SHORTCARD j;
  437.  
  438.   Idents_GetString(i, &s);
  439.   {
  440.     SHORTCARD B_3 = 1, B_4 = Strings_Length(&s);
  441.  
  442.     if (B_3 <= B_4)
  443.       for (j = B_3;; j += 1) {
  444.         Ch = Strings_Char(&s, j);
  445.         if (Ch == '{' || Ch == '}' || Ch == '\\') {
  446.           IO_WriteC(Tree_f, '\\');
  447.         }
  448.         IO_WriteC(Tree_f, Ch);
  449.         if (j >= B_4) break;
  450.       }
  451.   }
  452. }
  453.  
  454. void Tree_WN
  455. # ifdef __STDC__
  456. (INTEGER n)
  457. # else
  458. (n)
  459. INTEGER n;
  460. # endif
  461. {
  462.   IO_WriteI(Tree_f, n, 0L);
  463. }
  464.  
  465. void Tree_BeginTree2
  466. # ifdef __STDC__
  467. ()
  468. # else
  469. ()
  470. # endif
  471. {
  472.   Strings_tString Word;
  473.  
  474.   {
  475.     register Tree_yAg *W_1 = &Tree_TreeRoot->U_1.V_26.Ag;
  476.  
  477.     if (W_1->ParserName == Idents_NoIdent) {
  478.       Strings_ArrayToString((STRING)"Parser", 6L, &Word);
  479.       W_1->ParserName = Idents_MakeIdent(&Word);
  480.     }
  481.     if (W_1->TreeName == Idents_NoIdent) {
  482.       Strings_ArrayToString((STRING)"Tree", 4L, &Word);
  483.       W_1->TreeName = Idents_MakeIdent(&Word);
  484.     }
  485.     if (W_1->EvalName == Idents_NoIdent) {
  486.       Strings_ArrayToString((STRING)"Eval", 4L, &Word);
  487.       W_1->EvalName = Idents_MakeIdent(&Word);
  488.     }
  489.     if (Tree_ViewName == Idents_NoIdent) {
  490.       Tree_ViewName = W_1->TreeName;
  491.     }
  492.     Idents_GetString(W_1->TreeName, &Tree_ModuleName);
  493.     Tree_iMain = W_1->TreeName;
  494.   }
  495.   Strings_ArrayToString((STRING)"t", 1L, &Word);
  496.   Strings_Concatenate(&Word, &Tree_ModuleName);
  497.   Tree_itTree = Idents_MakeIdent(&Word);
  498.   Strings_ArrayToString((STRING)"No", 2L, &Word);
  499.   Strings_Concatenate(&Word, &Tree_ModuleName);
  500.   Tree_iNoTree = Idents_MakeIdent(&Word);
  501.   Strings_ArrayToString((STRING)"Position", 8L, &Word);
  502.   Tree_iPosition = Idents_MakeIdent(&Word);
  503.   Strings_ArrayToString((STRING)"tPosition", 9L, &Word);
  504.   Tree_itPosition = Idents_MakeIdent(&Word);
  505.   if (Tree_SubUnit == Idents_NoIdent) {
  506.     Tree_iModule = Tree_iMain;
  507.   } else {
  508.     Tree_iModule = Tree_SubUnit;
  509.     Sets_Include(&Tree_Options, ORD('<'));
  510.   }
  511. }
  512.  
  513. Tree_tTree Tree_IdentifyModule
  514. # ifdef __STDC__
  515. (Tree_tTree t, Idents_tIdent Ident)
  516. # else
  517. (t, Ident)
  518. Tree_tTree t;
  519. Idents_tIdent Ident;
  520. # endif
  521. {
  522.   Tree_tTree module;
  523.  
  524.   if (t->U_1.V_1.Kind == Tree_Module) {
  525.     if (t->U_1.V_43.Module.Name == Ident) {
  526.       return t;
  527.     }
  528.     return Tree_IdentifyModule(t->U_1.V_43.Module.Next, Ident);
  529.   } else {
  530.     return Tree_NoTree;
  531.   }
  532. }
  533.  
  534. void Tree_WriteInstance
  535. # ifdef __STDC__
  536. (Tree_tInstance i)
  537. # else
  538. (i)
  539. Tree_tInstance i;
  540. # endif
  541. {
  542.   {
  543.     register Tree_tInstance *W_2 = &i;
  544.  
  545.     IO_WriteS((System_tFile)IO_StdOutput, (STRING)" ", 1L);
  546.     Tree_WriteName(i);
  547.     IO_WriteS((System_tFile)IO_StdOutput, (STRING)"    ", 1L);
  548.     IO_WriteI((System_tFile)IO_StdOutput, (LONGINT)W_2->Attribute->U_1.V_9.Child.Partition, 0L);
  549.     IO_WriteS((System_tFile)IO_StdOutput, (STRING)" ", 1L);
  550.     Tree_WriteAttrProperties((System_tFile)IO_StdOutput, W_2->Properties | W_2->Attribute->U_1.V_9.Child.Properties);
  551.     IO_WriteNl((System_tFile)IO_StdOutput);
  552.   }
  553. }
  554.  
  555. void Tree_WriteName
  556. # ifdef __STDC__
  557. (Tree_tInstance i)
  558. # else
  559. (i)
  560. Tree_tInstance i;
  561. # endif
  562. {
  563.   {
  564.     register Tree_tInstance *W_3 = &i;
  565.  
  566.     if (W_3->Selector != Tree_NoTree && IN(Tree_Right, W_3->Properties)) {
  567.       Idents_WriteIdent((System_tFile)IO_StdOutput, W_3->Selector->U_1.V_9.Child.Name);
  568.       IO_WriteS((System_tFile)IO_StdOutput, (STRING)":", 1L);
  569.     }
  570.     if (W_3->Attribute != Tree_NoTree) {
  571.       Idents_WriteIdent((System_tFile)IO_StdOutput, W_3->Attribute->U_1.V_9.Child.Name);
  572.     }
  573.   }
  574. }
  575.  
  576. void Tree_WriteAttrProperties
  577. # ifdef __STDC__
  578. (IO_tFile f, Tree_tAttrProperties Properties)
  579. # else
  580. (f, Properties)
  581. IO_tFile f;
  582. Tree_tAttrProperties Properties;
  583. # endif
  584. {
  585.   if (IN(Tree_Virtual, Properties)) {
  586.     IO_WriteS(f, (STRING)"Virtual ", 8L);
  587.   }
  588.   if (IN(Tree_Computed, Properties)) {
  589.     IO_WriteS(f, (STRING)"Computed ", 9L);
  590.   }
  591.   if (IN(Tree_Reverse, Properties)) {
  592.     IO_WriteS(f, (STRING)"Reverse ", 8L);
  593.   }
  594.   if (IN(Tree_Write, Properties)) {
  595.     IO_WriteS(f, (STRING)"Write ", 6L);
  596.   }
  597.   if (IN(Tree_Read, Properties)) {
  598.     IO_WriteS(f, (STRING)"Read ", 5L);
  599.   }
  600.   if (IN(Tree_Inherited, Properties)) {
  601.     IO_WriteS(f, (STRING)"Inherited ", 10L);
  602.   }
  603.   if (IN(Tree_Synthesized, Properties)) {
  604.     IO_WriteS(f, (STRING)"Synthesized ", 12L);
  605.   }
  606.   if (IN(Tree_Input, Properties)) {
  607.     IO_WriteS(f, (STRING)"Input ", 6L);
  608.   }
  609.   if (IN(Tree_Output, Properties)) {
  610.     IO_WriteS(f, (STRING)"Output ", 7L);
  611.   }
  612.   if (IN(Tree_Tree, Properties)) {
  613.     IO_WriteS(f, (STRING)"Tree ", 5L);
  614.   }
  615.   if (IN(Tree_Parameter, Properties)) {
  616.     IO_WriteS(f, (STRING)"Parameter ", 10L);
  617.   }
  618.   if (IN(Tree_Stack, Properties)) {
  619.     IO_WriteS(f, (STRING)"Stack ", 6L);
  620.   }
  621.   if (IN(Tree_Variable, Properties)) {
  622.     IO_WriteS(f, (STRING)"Variable ", 9L);
  623.   }
  624.   if (IN(Tree_Demand, Properties)) {
  625.     IO_WriteS(f, (STRING)"Demand ", 7L);
  626.   }
  627.   if (IN(Tree_Funct, Properties)) {
  628.     IO_WriteS(f, (STRING)"Function ", 9L);
  629.   }
  630.   if (IN(Tree_Ignore, Properties)) {
  631.     IO_WriteS(f, (STRING)"Ignore ", 7L);
  632.   }
  633.   if (IN(Tree_Thread, Properties)) {
  634.     IO_WriteS(f, (STRING)"Thread ", 7L);
  635.   }
  636.   if (IN(Tree_Test, Properties)) {
  637.     IO_WriteS(f, (STRING)"Test ", 5L);
  638.   }
  639.   if (IN(Tree_Left, Properties)) {
  640.     IO_WriteS(f, (STRING)"Left ", 5L);
  641.   }
  642.   if (IN(Tree_Right, Properties)) {
  643.     IO_WriteS(f, (STRING)"Right ", 6L);
  644.   }
  645.   if (IN(Tree_CopyDef, Properties)) {
  646.     IO_WriteS(f, (STRING)"CopyDef ", 8L);
  647.   }
  648.   if (IN(Tree_CopyUse, Properties)) {
  649.     IO_WriteS(f, (STRING)"CopyUse ", 8L);
  650.   }
  651.   if (IN(Tree_NonBaseComp, Properties)) {
  652.     IO_WriteS(f, (STRING)"NonBaseComp ", 12L);
  653.   }
  654.   if (IN(Tree_MultInhComp, Properties)) {
  655.     IO_WriteS(f, (STRING)"MultInhComp ", 12L);
  656.   }
  657.   if (IN(Tree_First, Properties)) {
  658.     IO_WriteS(f, (STRING)"First ", 6L);
  659.   }
  660.   if (IN(Tree_Dummy, Properties)) {
  661.     IO_WriteS(f, (STRING)"Dummy ", 6L);
  662.   }
  663.   if (IN(Tree_Def, Properties)) {
  664.     IO_WriteS(f, (STRING)"Def ", 4L);
  665.   }
  666.   if (IN(Tree_Use, Properties)) {
  667.     IO_WriteS(f, (STRING)"Use ", 4L);
  668.   }
  669.   if (IN(Tree_ChildUse, Properties)) {
  670.     IO_WriteS(f, (STRING)"ChildUse ", 9L);
  671.   }
  672.   if (IN(Tree_ParentUse, Properties)) {
  673.     IO_WriteS(f, (STRING)"ParentUse ", 10L);
  674.   }
  675.   if (IN(Tree_Generated, Properties)) {
  676.     IO_WriteS(f, (STRING)"Generated ", 10L);
  677.   }
  678. }
  679.  
  680. void Tree_WriteClassProperties
  681. # ifdef __STDC__
  682. (IO_tFile f, Tree_tClassProperties Properties)
  683. # else
  684. (f, Properties)
  685. IO_tFile f;
  686. Tree_tClassProperties Properties;
  687. # endif
  688. {
  689.   if (IN(Tree_Top, Properties)) {
  690.     IO_WriteS(f, (STRING)"Top ", 4L);
  691.   }
  692.   if (IN(Tree_Intermediate, Properties)) {
  693.     IO_WriteS(f, (STRING)"Intermediate ", 13L);
  694.   }
  695.   if (IN(Tree_Low, Properties)) {
  696.     IO_WriteS(f, (STRING)"Low ", 4L);
  697.   }
  698.   if (IN(Tree_Referenced, Properties)) {
  699.     IO_WriteS(f, (STRING)"Referenced ", 11L);
  700.   }
  701.   if (IN(Tree_Reachable, Properties)) {
  702.     IO_WriteS(f, (STRING)"Reachable ", 10L);
  703.   }
  704.   if (IN(Tree_Nonterminal, Properties)) {
  705.     IO_WriteS(f, (STRING)"Nonterminal ", 12L);
  706.   }
  707.   if (IN(Tree_Terminal, Properties)) {
  708.     IO_WriteS(f, (STRING)"Terminal ", 9L);
  709.   }
  710.   if (IN(Tree_Explicit, Properties)) {
  711.     IO_WriteS(f, (STRING)"Explicit ", 9L);
  712.   }
  713.   if (IN(Tree_Implicit, Properties)) {
  714.     IO_WriteS(f, (STRING)"Implicit ", 9L);
  715.   }
  716.   if (IN(Tree_Trace, Properties)) {
  717.     IO_WriteS(f, (STRING)"Trace ", 6L);
  718.   }
  719.   if (IN(Tree_String, Properties)) {
  720.     IO_WriteS(f, (STRING)"String ", 7L);
  721.   }
  722.   if (IN(Tree_HasSelector, Properties)) {
  723.     IO_WriteS(f, (STRING)"HasSelector ", 12L);
  724.   }
  725.   if (IN(Tree_HasChildren, Properties)) {
  726.     IO_WriteS(f, (STRING)"HasChildren ", 12L);
  727.   }
  728.   if (IN(Tree_HasAttributes, Properties)) {
  729.     IO_WriteS(f, (STRING)"HasAttributes ", 14L);
  730.   }
  731.   if (IN(Tree_HasActions, Properties)) {
  732.     IO_WriteS(f, (STRING)"HasActions ", 11L);
  733.   }
  734.   if (IN(Tree_Abstract, Properties)) {
  735.     IO_WriteS(f, (STRING)"Abstract ", 9L);
  736.   }
  737.   if (IN(Tree_Mark, Properties)) {
  738.     IO_WriteS(f, (STRING)"Mark ", 5L);
  739.   }
  740.   if (IN(Tree_HasOutput, Properties)) {
  741.     IO_WriteS(f, (STRING)"HasOutput ", 10L);
  742.   }
  743. }
  744.  
  745. void Tree_WriteDependencies
  746. # ifdef __STDC__
  747. (Tree_tTree t, Relations_tRelation r, Sets_tSet s)
  748. # else
  749. (t, r, s)
  750. Tree_tTree t;
  751. Relations_tRelation r;
  752. Sets_tSet s;
  753. # endif
  754. {
  755.   SHORTCARD i, j, k, count;
  756.  
  757.   if (t == Tree_NoTree || r.Size1 != t->U_1.V_5.Class.InstCount) {
  758.     return;
  759.   }
  760.   Idents_WriteIdent((System_tFile)IO_StdOutput, t->U_1.V_5.Class.Name);
  761.   IO_WriteS((System_tFile)IO_StdOutput, (STRING)"    ", 1L);
  762.   Tree_WriteClassProperties((System_tFile)IO_StdOutput, t->U_1.V_5.Class.Properties);
  763.   IO_WriteNl((System_tFile)IO_StdOutput);
  764.   IO_WriteNl((System_tFile)IO_StdOutput);
  765.   {
  766.     SHORTCARD B_5 = 1, B_6 = t->U_1.V_5.Class.InstCount;
  767.  
  768.     if (B_5 <= B_6)
  769.       for (i = B_5;; i += 1) {
  770.         if (Sets_IsElement((LONGCARD)i, &s) && !IN(Tree_Dummy, t->U_1.V_5.Class.Instance->A[i - 1].Properties)) {
  771.           Tree_WriteName(t->U_1.V_5.Class.Instance->A[i - 1]);
  772.           IO_WriteS((System_tFile)IO_StdOutput, (STRING)"    :", 2L);
  773.           count = 0;
  774.           k = 0;
  775.           {
  776.             SHORTCARD B_7 = 1, B_8 = t->U_1.V_5.Class.InstCount;
  777.  
  778.             if (B_7 <= B_8)
  779.               for (j = B_7;; j += 1) {
  780.                 if (Sets_IsElement((LONGCARD)j, &s) && Relations_IsRelated((LONGINT)i, (LONGINT)j, r)) {
  781.                   if (count == 5) {
  782.                     IO_WriteNl((System_tFile)IO_StdOutput);
  783.                     IO_WriteS((System_tFile)IO_StdOutput, (STRING)"    ", 1L);
  784.                     count = 0;
  785.                   }
  786.                   IO_WriteS((System_tFile)IO_StdOutput, (STRING)" ", 1L);
  787.                   Tree_WriteName(t->U_1.V_5.Class.Instance->A[j - 1]);
  788.                   INC(count);
  789.                   INC(k);
  790.                 }
  791.                 if (j >= B_8) break;
  792.               }
  793.           }
  794.           IO_WriteS((System_tFile)IO_StdOutput, (STRING)" (", 2L);
  795.           IO_WriteI((System_tFile)IO_StdOutput, (LONGINT)k, 0L);
  796.           IO_WriteS((System_tFile)IO_StdOutput, (STRING)")", 1L);
  797.           IO_WriteNl((System_tFile)IO_StdOutput);
  798.         }
  799.         if (i >= B_6) break;
  800.       }
  801.   }
  802.   IO_WriteNl((System_tFile)IO_StdOutput);
  803. }
  804.  
  805. void Tree_WriteCyclics
  806. # ifdef __STDC__
  807. (Tree_tTree t, Sets_tSet s)
  808. # else
  809. (t, s)
  810. Tree_tTree t;
  811. Sets_tSet s;
  812. # endif
  813. {
  814.   SHORTCARD i, count;
  815.  
  816.   count = 0;
  817.   {
  818.     SHORTCARD B_9 = 1, B_10 = t->U_1.V_5.Class.InstCount;
  819.  
  820.     if (B_9 <= B_10)
  821.       for (i = B_9;; i += 1) {
  822.         if (Sets_IsElement((LONGCARD)i, &s)) {
  823.           if (count == 5) {
  824.             IO_WriteNl((System_tFile)IO_StdOutput);
  825.             count = 0;
  826.           }
  827.           Tree_WriteName(t->U_1.V_5.Class.Instance->A[i - 1]);
  828.           IO_WriteS((System_tFile)IO_StdOutput, (STRING)" ", 1L);
  829.           INC(count);
  830.         }
  831.         if (i >= B_10) break;
  832.       }
  833.   }
  834.   IO_WriteNl((System_tFile)IO_StdOutput);
  835. }
  836.  
  837. void Tree_WriteClass
  838. # ifdef __STDC__
  839. (Tree_tTree t)
  840. # else
  841. (t)
  842. Tree_tTree t;
  843. # endif
  844. {
  845.   SHORTCARD i;
  846.  
  847.   switch (t->U_1.V_1.Kind) {
  848.   case Tree_Class:;
  849.     {
  850.       register Tree_yClass *W_4 = &t->U_1.V_5.Class;
  851.  
  852.       Idents_WriteIdent((System_tFile)IO_StdOutput, W_4->Name);
  853.       IO_WriteS((System_tFile)IO_StdOutput, (STRING)" =", 2L);
  854.       IO_WriteNl((System_tFile)IO_StdOutput);
  855.       Tree_ForallAttributes(t, (Tree_ProcOfT)Tree_WriteClass);
  856.       IO_WriteNl((System_tFile)IO_StdOutput);
  857.       {
  858.         SHORTCARD B_11 = 1, B_12 = W_4->InstCount;
  859.  
  860.         if (B_11 <= B_12)
  861.           for (i = B_11;; i += 1) {
  862.             {
  863.               register Tree_tInstance *W_5 = &W_4->Instance->A[i - 1];
  864.  
  865.               if (W_5->Action != ADR(W_5->Action)) {
  866.                 if (IN(Tree_Test, W_5->Properties)) {
  867.                   Tree_WriteName(W_4->Instance->A[i - 1]);
  868.                   IO_WriteS((System_tFile)IO_StdOutput, (STRING)":", 1L);
  869.                 }
  870.                 IO_WriteS((System_tFile)IO_StdOutput, (STRING)"    {", 2L);
  871.                 Tree_WriteClass(W_5->Action);
  872.                 IO_WriteS((System_tFile)IO_StdOutput, (STRING)"}", 1L);
  873.                 IO_WriteNl((System_tFile)IO_StdOutput);
  874.               }
  875.             }
  876.             if (i >= B_12) break;
  877.           }
  878.       }
  879.       IO_WriteS((System_tFile)IO_StdOutput, (STRING)".", 1L);
  880.       IO_WriteNl((System_tFile)IO_StdOutput);
  881.     }
  882.     break;
  883.   case Tree_Child:;
  884.     {
  885.       register Tree_yChild *W_6 = &t->U_1.V_9.Child;
  886.  
  887.       IO_WriteS((System_tFile)IO_StdOutput, (STRING)"    ", 1L);
  888.       Idents_WriteIdent((System_tFile)IO_StdOutput, W_6->Name);
  889.       IO_WriteS((System_tFile)IO_StdOutput, (STRING)": ", 2L);
  890.       Idents_WriteIdent((System_tFile)IO_StdOutput, W_6->Type);
  891.       IO_WriteNl((System_tFile)IO_StdOutput);
  892.     }
  893.     break;
  894.   case Tree_Attribute:;
  895.     {
  896.       register Tree_yAttribute *W_7 = &t->U_1.V_10.Attribute;
  897.  
  898.       IO_WriteS((System_tFile)IO_StdOutput, (STRING)"    [", 2L);
  899.       Idents_WriteIdent((System_tFile)IO_StdOutput, W_7->Name);
  900.       IO_WriteS((System_tFile)IO_StdOutput, (STRING)": ", 2L);
  901.       Idents_WriteIdent((System_tFile)IO_StdOutput, W_7->Type);
  902.       IO_WriteS((System_tFile)IO_StdOutput, (STRING)"]", 1L);
  903.       IO_WriteNl((System_tFile)IO_StdOutput);
  904.     }
  905.     break;
  906.   case Tree_Assign:;
  907.     {
  908.       register Tree_yAssign *W_8 = &t->U_1.V_36.Assign;
  909.  
  910.       Tree_WriteClass(W_8->Results);
  911.       IO_WriteS((System_tFile)IO_StdOutput, (STRING)":=", 2L);
  912.       Tree_WriteClass(W_8->Arguments);
  913.       IO_WriteS((System_tFile)IO_StdOutput, (STRING)";", 1L);
  914.     }
  915.     break;
  916.   case Tree_Copy:;
  917.     {
  918.       register Tree_yCopy *W_9 = &t->U_1.V_37.Copy;
  919.  
  920.       Tree_WriteClass(W_9->Results);
  921.       IO_WriteS((System_tFile)IO_StdOutput, (STRING)" :- ", 4L);
  922.       Tree_WriteClass(W_9->Arguments);
  923.       IO_WriteS((System_tFile)IO_StdOutput, (STRING)";", 1L);
  924.     }
  925.     break;
  926.   case Tree_TargetCode:;
  927.     {
  928.       register Tree_yTargetCode *W_10 = &t->U_1.V_38.TargetCode;
  929.  
  930.       if (W_10->Results->U_1.V_1.Kind != Tree_NoDesignator) {
  931.         Tree_WriteClass(W_10->Results);
  932.         IO_WriteS((System_tFile)IO_StdOutput, (STRING)":= {", 4L);
  933.         Tree_WriteClass(W_10->Code);
  934.         IO_WriteS((System_tFile)IO_StdOutput, (STRING)"};", 2L);
  935.       }
  936.     }
  937.     break;
  938.   case Tree_Order:;
  939.     {
  940.       register Tree_yOrder *W_11 = &t->U_1.V_39.Order;
  941.  
  942.       Tree_WriteClass(W_11->Results);
  943.       IO_WriteS((System_tFile)IO_StdOutput, (STRING)" AFTER ", 7L);
  944.       Tree_WriteClass(W_11->Arguments);
  945.       IO_WriteS((System_tFile)IO_StdOutput, (STRING)";", 1L);
  946.     }
  947.     break;
  948.   case Tree_Check:;
  949.     {
  950.       register Tree_yCheck *W_12 = &t->U_1.V_40.Check;
  951.  
  952.       if (W_12->Condition != Tree_NoTree) {
  953.         IO_WriteS((System_tFile)IO_StdOutput, (STRING)"CHECK ", 6L);
  954.         Tree_WriteClass(W_12->Condition);
  955.       }
  956.       if (W_12->Statement != Tree_NoTree) {
  957.         IO_WriteS((System_tFile)IO_StdOutput, (STRING)" => { ", 6L);
  958.         Tree_WriteClass(W_12->Statement);
  959.         IO_WriteS((System_tFile)IO_StdOutput, (STRING)"}", 1L);
  960.       }
  961.       Tree_WriteClass(W_12->Actions);
  962.       IO_WriteS((System_tFile)IO_StdOutput, (STRING)";", 1L);
  963.     }
  964.     break;
  965.   case Tree_Designator:;
  966.     {
  967.       register Tree_yDesignator *W_13 = &t->U_1.V_15.Designator;
  968.  
  969.       Idents_WriteIdent((System_tFile)IO_StdOutput, W_13->Selector);
  970.       IO_WriteS((System_tFile)IO_StdOutput, (STRING)":", 1L);
  971.       Idents_WriteIdent((System_tFile)IO_StdOutput, W_13->Attribute);
  972.       Tree_WriteClass(W_13->Next);
  973.     }
  974.     break;
  975.   case Tree_Ident:;
  976.     {
  977.       register Tree_yIdent *W_14 = &t->U_1.V_16.Ident;
  978.  
  979.       Idents_WriteIdent((System_tFile)IO_StdOutput, W_14->Attribute);
  980.       Tree_WriteClass(W_14->Next);
  981.     }
  982.     break;
  983.   case Tree_Remote:;
  984.     {
  985.       register Tree_yRemote *W_15 = &t->U_1.V_17.Remote;
  986.  
  987.       IO_WriteS((System_tFile)IO_StdOutput, (STRING)"REMOTE ", 7L);
  988.       Tree_WriteClass(W_15->Designators);
  989.       IO_WriteS((System_tFile)IO_StdOutput, (STRING)"=>", 2L);
  990.       Idents_WriteIdent((System_tFile)IO_StdOutput, W_15->Type);
  991.       IO_WriteS((System_tFile)IO_StdOutput, (STRING)":", 1L);
  992.       Idents_WriteIdent((System_tFile)IO_StdOutput, W_15->Attribute);
  993.       Tree_WriteClass(W_15->Next);
  994.     }
  995.     break;
  996.   case Tree_Any:;
  997.     {
  998.       register Tree_yAny *W_16 = &t->U_1.V_18.Any;
  999.  
  1000.       StringMem_WriteString((System_tFile)IO_StdOutput, W_16->Code);
  1001.       Tree_WriteClass(W_16->Next);
  1002.     }
  1003.     break;
  1004.   case Tree_Anys:;
  1005.     {
  1006.       register Tree_yAnys *W_17 = &t->U_1.V_19.Anys;
  1007.  
  1008.       Tree_WriteClass(W_17->Layouts);
  1009.       Tree_WriteClass(W_17->Next);
  1010.     }
  1011.     break;
  1012.   case Tree_LayoutAny:;
  1013.     {
  1014.       register Tree_yLayoutAny *W_18 = &t->U_1.V_22.LayoutAny;
  1015.  
  1016.       StringMem_WriteString((System_tFile)IO_StdOutput, W_18->Code);
  1017.       Tree_WriteClass(W_18->Next);
  1018.     }
  1019.     break;
  1020.   default :
  1021.     break;
  1022.   }
  1023. }
  1024.  
  1025. BOOLEAN Tree_HasItem
  1026. # ifdef __STDC__
  1027. (Tree_tTree t, SHORTCARD Item)
  1028. # else
  1029. (t, Item)
  1030. Tree_tTree t;
  1031. SHORTCARD Item;
  1032. # endif
  1033. {
  1034.   switch (t->U_1.V_1.Kind) {
  1035.   case Tree_Class:;
  1036.     return Tree_HasItem(t->U_1.V_5.Class.BaseClass, Item) || Tree_HasItem(t->U_1.V_5.Class.Attributes, Item);
  1037.     break;
  1038.   case Tree_NoClass:;
  1039.   case Tree_NoAttribute:;
  1040.     return FALSE;
  1041.     break;
  1042.   default :
  1043.     return t->U_1.V_8.AttrOrAction.Item == Item || Tree_HasItem(t->U_1.V_8.AttrOrAction.Next, Item);
  1044.     break;
  1045.   }
  1046. }
  1047.  
  1048. Tree_tTree Tree_yyAlloc
  1049. # ifdef __STDC__
  1050. ()
  1051. # else
  1052. ()
  1053. # endif
  1054. {
  1055.   yytBlockPtr yyBlockPtr;
  1056.  
  1057.   yyBlockPtr = yyBlockList;
  1058.   yyBlockList = (yytBlockPtr)Memory_Alloc((LONGINT)sizeof(yytBlock));
  1059.   yyBlockList->yySuccessor = yyBlockPtr;
  1060.   Tree_yyPoolFreePtr = ADR(yyBlockList->yyBlock);
  1061.   Tree_yyPoolMaxPtr = (ADDRESS)(Tree_yyPoolFreePtr + yyBlockSize - yyMaxSize + 1);
  1062.   INC1(Tree_HeapUsed, yyBlockSize);
  1063.   return (Tree_tTree)Tree_yyPoolFreePtr;
  1064. }
  1065.  
  1066. Tree_tTree Tree_MakeTree
  1067. # ifdef __STDC__
  1068. (SHORTCARD yyKind)
  1069. # else
  1070. (yyKind)
  1071. SHORTCARD yyKind;
  1072. # endif
  1073. {
  1074.   LONGINT yyByteCount;
  1075.   Tree_tTree yyt;
  1076.  
  1077.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1078.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1079.     yyt = Tree_yyAlloc();
  1080.   }
  1081.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[yyKind]);
  1082.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1083.   yyt->U_1.V_1.Kind = yyKind;
  1084.   return yyt;
  1085. }
  1086.  
  1087. BOOLEAN Tree_IsType
  1088. # ifdef __STDC__
  1089. (Tree_tTree yyTree, SHORTCARD yyKind)
  1090. # else
  1091. (yyTree, yyKind)
  1092. Tree_tTree yyTree;
  1093. SHORTCARD yyKind;
  1094. # endif
  1095. {
  1096.   return yyTree != Tree_NoTree && yyKind <= yyTree->U_1.V_1.Kind && yyTree->U_1.V_1.Kind <= yyTypeRange.A[yyKind];
  1097. }
  1098.  
  1099. Tree_tTree Tree_mClasses
  1100. # ifdef __STDC__
  1101. ()
  1102. # else
  1103. ()
  1104. # endif
  1105. {
  1106.   LONGINT yyByteCount;
  1107.   Tree_tTree yyt;
  1108.  
  1109.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1110.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1111.     yyt = Tree_yyAlloc();
  1112.   }
  1113.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Classes]);
  1114.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1115.   yyt->U_1.V_1.Kind = Tree_Classes;
  1116.   return yyt;
  1117. }
  1118.  
  1119. Tree_tTree Tree_mNoClass
  1120. # ifdef __STDC__
  1121. ()
  1122. # else
  1123. ()
  1124. # endif
  1125. {
  1126.   LONGINT yyByteCount;
  1127.   Tree_tTree yyt;
  1128.  
  1129.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1130.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1131.     yyt = Tree_yyAlloc();
  1132.   }
  1133.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_NoClass]);
  1134.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1135.   yyt->U_1.V_1.Kind = Tree_NoClass;
  1136.   return yyt;
  1137. }
  1138.  
  1139. Tree_tTree Tree_mClass
  1140. # ifdef __STDC__
  1141. (Idents_tIdent pName, Tree_tClassProperties pProperties, Tree_tTree pAttributes, Tree_tTree pExtensions, Tree_tTree pNext, Idents_tIdent pSelector, Positions_tPosition pPos, SHORTCARD pCode, Idents_tIdent pPrec, Tree_tTree pNames)
  1142. # else
  1143. (pName, pProperties, pAttributes, pExtensions, pNext, pSelector, pPos, pCode, pPrec, pNames)
  1144. Idents_tIdent pName;
  1145. Tree_tClassProperties pProperties;
  1146. Tree_tTree pAttributes;
  1147. Tree_tTree pExtensions;
  1148. Tree_tTree pNext;
  1149. Idents_tIdent pSelector;
  1150. Positions_tPosition pPos;
  1151. SHORTCARD pCode;
  1152. Idents_tIdent pPrec;
  1153. Tree_tTree pNames;
  1154. # endif
  1155. {
  1156.   LONGINT yyByteCount;
  1157.   Tree_tTree yyt;
  1158.  
  1159.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1160.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1161.     yyt = Tree_yyAlloc();
  1162.   }
  1163.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Class]);
  1164.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1165.   yyt->U_1.V_1.Kind = Tree_Class;
  1166.   {
  1167.     register Tree_yClass *W_19 = &yyt->U_1.V_5.Class;
  1168.  
  1169.     W_19->Name = pName;
  1170.     W_19->Properties = pProperties;
  1171.     W_19->Attributes = pAttributes;
  1172.     W_19->Extensions = pExtensions;
  1173.     W_19->Next = pNext;
  1174.     W_19->BaseClass = Tree_NoTree;
  1175.     W_19->Selector = pSelector;
  1176.     W_19->Pos = pPos;
  1177.     W_19->Code = pCode;
  1178.     W_19->Prec = pPrec;
  1179.     W_19->Names = pNames;
  1180.     W_19->DP = DummyRelation;
  1181.     W_19->SNC = DummyRelation;
  1182.     W_19->DNC = DummyRelation;
  1183.     W_19->OAG = DummyRelation;
  1184.     W_19->Part = DummyRelation;
  1185.     W_19->Users = DummySet;
  1186.     W_19->Generated = 0;
  1187.   }
  1188.   return yyt;
  1189. }
  1190.  
  1191. Tree_tTree Tree_mAttributes
  1192. # ifdef __STDC__
  1193. ()
  1194. # else
  1195. ()
  1196. # endif
  1197. {
  1198.   LONGINT yyByteCount;
  1199.   Tree_tTree yyt;
  1200.  
  1201.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1202.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1203.     yyt = Tree_yyAlloc();
  1204.   }
  1205.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Attributes]);
  1206.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1207.   yyt->U_1.V_1.Kind = Tree_Attributes;
  1208.   return yyt;
  1209. }
  1210.  
  1211. Tree_tTree Tree_mNoAttribute
  1212. # ifdef __STDC__
  1213. ()
  1214. # else
  1215. ()
  1216. # endif
  1217. {
  1218.   LONGINT yyByteCount;
  1219.   Tree_tTree yyt;
  1220.  
  1221.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1222.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1223.     yyt = Tree_yyAlloc();
  1224.   }
  1225.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_NoAttribute]);
  1226.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1227.   yyt->U_1.V_1.Kind = Tree_NoAttribute;
  1228.   return yyt;
  1229. }
  1230.  
  1231. Tree_tTree Tree_mAttrOrAction
  1232. # ifdef __STDC__
  1233. (Tree_tTree pNext)
  1234. # else
  1235. (pNext)
  1236. Tree_tTree pNext;
  1237. # endif
  1238. {
  1239.   LONGINT yyByteCount;
  1240.   Tree_tTree yyt;
  1241.  
  1242.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1243.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1244.     yyt = Tree_yyAlloc();
  1245.   }
  1246.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_AttrOrAction]);
  1247.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1248.   yyt->U_1.V_1.Kind = Tree_AttrOrAction;
  1249.   {
  1250.     register Tree_yAttrOrAction *W_20 = &yyt->U_1.V_8.AttrOrAction;
  1251.  
  1252.     W_20->Next = pNext;
  1253.   }
  1254.   return yyt;
  1255. }
  1256.  
  1257. Tree_tTree Tree_mChild
  1258. # ifdef __STDC__
  1259. (Tree_tTree pNext, Idents_tIdent pName, Idents_tIdent pType, Tree_tAttrProperties pProperties, Positions_tPosition pPos)
  1260. # else
  1261. (pNext, pName, pType, pProperties, pPos)
  1262. Tree_tTree pNext;
  1263. Idents_tIdent pName;
  1264. Idents_tIdent pType;
  1265. Tree_tAttrProperties pProperties;
  1266. Positions_tPosition pPos;
  1267. # endif
  1268. {
  1269.   LONGINT yyByteCount;
  1270.   Tree_tTree yyt;
  1271.  
  1272.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1273.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1274.     yyt = Tree_yyAlloc();
  1275.   }
  1276.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Child]);
  1277.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1278.   yyt->U_1.V_1.Kind = Tree_Child;
  1279.   {
  1280.     register Tree_yChild *W_21 = &yyt->U_1.V_9.Child;
  1281.  
  1282.     W_21->Next = pNext;
  1283.     W_21->Name = pName;
  1284.     W_21->Type = pType;
  1285.     W_21->Properties = pProperties;
  1286.     W_21->Pos = pPos;
  1287.     W_21->Partition = 9999;
  1288.     W_21->Usage = 0X0L;
  1289.   }
  1290.   return yyt;
  1291. }
  1292.  
  1293. Tree_tTree Tree_mAttribute
  1294. # ifdef __STDC__
  1295. (Tree_tTree pNext, Idents_tIdent pName, Idents_tIdent pType, Tree_tAttrProperties pProperties, Positions_tPosition pPos)
  1296. # else
  1297. (pNext, pName, pType, pProperties, pPos)
  1298. Tree_tTree pNext;
  1299. Idents_tIdent pName;
  1300. Idents_tIdent pType;
  1301. Tree_tAttrProperties pProperties;
  1302. Positions_tPosition pPos;
  1303. # endif
  1304. {
  1305.   LONGINT yyByteCount;
  1306.   Tree_tTree yyt;
  1307.  
  1308.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1309.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1310.     yyt = Tree_yyAlloc();
  1311.   }
  1312.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Attribute]);
  1313.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1314.   yyt->U_1.V_1.Kind = Tree_Attribute;
  1315.   {
  1316.     register Tree_yAttribute *W_22 = &yyt->U_1.V_10.Attribute;
  1317.  
  1318.     W_22->Next = pNext;
  1319.     W_22->Name = pName;
  1320.     W_22->Type = pType;
  1321.     W_22->Properties = pProperties;
  1322.     W_22->Pos = pPos;
  1323.     W_22->Partition = 9999;
  1324.     W_22->Usage = 0X0L;
  1325.   }
  1326.   return yyt;
  1327. }
  1328.  
  1329. Tree_tTree Tree_mActionPart
  1330. # ifdef __STDC__
  1331. (Tree_tTree pNext, Tree_tTree pActions)
  1332. # else
  1333. (pNext, pActions)
  1334. Tree_tTree pNext;
  1335. Tree_tTree pActions;
  1336. # endif
  1337. {
  1338.   LONGINT yyByteCount;
  1339.   Tree_tTree yyt;
  1340.  
  1341.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1342.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1343.     yyt = Tree_yyAlloc();
  1344.   }
  1345.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_ActionPart]);
  1346.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1347.   yyt->U_1.V_1.Kind = Tree_ActionPart;
  1348.   {
  1349.     register Tree_yActionPart *W_23 = &yyt->U_1.V_11.ActionPart;
  1350.  
  1351.     W_23->Next = pNext;
  1352.     W_23->Actions = pActions;
  1353.     W_23->Properties = 0X0L;
  1354.   }
  1355.   return yyt;
  1356. }
  1357.  
  1358. Tree_tTree Tree_mCodes
  1359. # ifdef __STDC__
  1360. (Texts_tText pExport, Texts_tText pImport, Texts_tText pGlobal, Texts_tText pLocal, Texts_tText pBegin, Texts_tText pClose, Positions_tPosition pExportLine, Positions_tPosition pImportLine, Positions_tPosition pGlobalLine, Positions_tPosition pLocalLine, Positions_tPosition pBeginLine, Positions_tPosition pCloseLine)
  1361. # else
  1362. (pExport, pImport, pGlobal, pLocal, pBegin, pClose, pExportLine, pImportLine, pGlobalLine, pLocalLine, pBeginLine, pCloseLine)
  1363. Texts_tText pExport;
  1364. Texts_tText pImport;
  1365. Texts_tText pGlobal;
  1366. Texts_tText pLocal;
  1367. Texts_tText pBegin;
  1368. Texts_tText pClose;
  1369. Positions_tPosition pExportLine;
  1370. Positions_tPosition pImportLine;
  1371. Positions_tPosition pGlobalLine;
  1372. Positions_tPosition pLocalLine;
  1373. Positions_tPosition pBeginLine;
  1374. Positions_tPosition pCloseLine;
  1375. # endif
  1376. {
  1377.   LONGINT yyByteCount;
  1378.   Tree_tTree yyt;
  1379.  
  1380.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1381.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1382.     yyt = Tree_yyAlloc();
  1383.   }
  1384.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Codes]);
  1385.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1386.   yyt->U_1.V_1.Kind = Tree_Codes;
  1387.   {
  1388.     register Tree_yCodes *W_24 = &yyt->U_1.V_12.Codes;
  1389.  
  1390.     W_24->Export = pExport;
  1391.     W_24->Import = pImport;
  1392.     W_24->Global = pGlobal;
  1393.     W_24->Local = pLocal;
  1394.     W_24->Begin = pBegin;
  1395.     W_24->Close = pClose;
  1396.     W_24->ExportLine = pExportLine;
  1397.     W_24->ImportLine = pImportLine;
  1398.     W_24->GlobalLine = pGlobalLine;
  1399.     W_24->LocalLine = pLocalLine;
  1400.     W_24->BeginLine = pBeginLine;
  1401.     W_24->CloseLine = pCloseLine;
  1402.   }
  1403.   return yyt;
  1404. }
  1405.  
  1406. Tree_tTree Tree_mDesignators
  1407. # ifdef __STDC__
  1408. ()
  1409. # else
  1410. ()
  1411. # endif
  1412. {
  1413.   LONGINT yyByteCount;
  1414.   Tree_tTree yyt;
  1415.  
  1416.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1417.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1418.     yyt = Tree_yyAlloc();
  1419.   }
  1420.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Designators]);
  1421.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1422.   yyt->U_1.V_1.Kind = Tree_Designators;
  1423.   return yyt;
  1424. }
  1425.  
  1426. Tree_tTree Tree_mNoDesignator
  1427. # ifdef __STDC__
  1428. ()
  1429. # else
  1430. ()
  1431. # endif
  1432. {
  1433.   LONGINT yyByteCount;
  1434.   Tree_tTree yyt;
  1435.  
  1436.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1437.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1438.     yyt = Tree_yyAlloc();
  1439.   }
  1440.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_NoDesignator]);
  1441.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1442.   yyt->U_1.V_1.Kind = Tree_NoDesignator;
  1443.   return yyt;
  1444. }
  1445.  
  1446. Tree_tTree Tree_mDesignator
  1447. # ifdef __STDC__
  1448. (Idents_tIdent pSelector, Idents_tIdent pAttribute, Positions_tPosition pPos, Tree_tTree pNext)
  1449. # else
  1450. (pSelector, pAttribute, pPos, pNext)
  1451. Idents_tIdent pSelector;
  1452. Idents_tIdent pAttribute;
  1453. Positions_tPosition pPos;
  1454. Tree_tTree pNext;
  1455. # endif
  1456. {
  1457.   LONGINT yyByteCount;
  1458.   Tree_tTree yyt;
  1459.  
  1460.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1461.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1462.     yyt = Tree_yyAlloc();
  1463.   }
  1464.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Designator]);
  1465.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1466.   yyt->U_1.V_1.Kind = Tree_Designator;
  1467.   {
  1468.     register Tree_yDesignator *W_25 = &yyt->U_1.V_15.Designator;
  1469.  
  1470.     W_25->Selector = pSelector;
  1471.     W_25->Attribute = pAttribute;
  1472.     W_25->Pos = pPos;
  1473.     W_25->Next = pNext;
  1474.   }
  1475.   return yyt;
  1476. }
  1477.  
  1478. Tree_tTree Tree_mIdent
  1479. # ifdef __STDC__
  1480. (Idents_tIdent pAttribute, Positions_tPosition pPos, Tree_tTree pNext)
  1481. # else
  1482. (pAttribute, pPos, pNext)
  1483. Idents_tIdent pAttribute;
  1484. Positions_tPosition pPos;
  1485. Tree_tTree pNext;
  1486. # endif
  1487. {
  1488.   LONGINT yyByteCount;
  1489.   Tree_tTree yyt;
  1490.  
  1491.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1492.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1493.     yyt = Tree_yyAlloc();
  1494.   }
  1495.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Ident]);
  1496.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1497.   yyt->U_1.V_1.Kind = Tree_Ident;
  1498.   {
  1499.     register Tree_yIdent *W_26 = &yyt->U_1.V_16.Ident;
  1500.  
  1501.     W_26->Attribute = pAttribute;
  1502.     W_26->Pos = pPos;
  1503.     W_26->Next = pNext;
  1504.   }
  1505.   return yyt;
  1506. }
  1507.  
  1508. Tree_tTree Tree_mRemote
  1509. # ifdef __STDC__
  1510. (Tree_tTree pDesignators, Idents_tIdent pType, Idents_tIdent pAttribute, Positions_tPosition pPos, Tree_tTree pNext)
  1511. # else
  1512. (pDesignators, pType, pAttribute, pPos, pNext)
  1513. Tree_tTree pDesignators;
  1514. Idents_tIdent pType;
  1515. Idents_tIdent pAttribute;
  1516. Positions_tPosition pPos;
  1517. Tree_tTree pNext;
  1518. # endif
  1519. {
  1520.   LONGINT yyByteCount;
  1521.   Tree_tTree yyt;
  1522.  
  1523.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1524.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1525.     yyt = Tree_yyAlloc();
  1526.   }
  1527.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Remote]);
  1528.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1529.   yyt->U_1.V_1.Kind = Tree_Remote;
  1530.   {
  1531.     register Tree_yRemote *W_27 = &yyt->U_1.V_17.Remote;
  1532.  
  1533.     W_27->Designators = pDesignators;
  1534.     W_27->Type = pType;
  1535.     W_27->Attribute = pAttribute;
  1536.     W_27->Pos = pPos;
  1537.     W_27->Next = pNext;
  1538.   }
  1539.   return yyt;
  1540. }
  1541.  
  1542. Tree_tTree Tree_mAny
  1543. # ifdef __STDC__
  1544. (StringMem_tStringRef pCode, Tree_tTree pNext)
  1545. # else
  1546. (pCode, pNext)
  1547. StringMem_tStringRef pCode;
  1548. Tree_tTree pNext;
  1549. # endif
  1550. {
  1551.   LONGINT yyByteCount;
  1552.   Tree_tTree yyt;
  1553.  
  1554.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1555.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1556.     yyt = Tree_yyAlloc();
  1557.   }
  1558.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Any]);
  1559.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1560.   yyt->U_1.V_1.Kind = Tree_Any;
  1561.   {
  1562.     register Tree_yAny *W_28 = &yyt->U_1.V_18.Any;
  1563.  
  1564.     W_28->Code = pCode;
  1565.     W_28->Next = pNext;
  1566.   }
  1567.   return yyt;
  1568. }
  1569.  
  1570. Tree_tTree Tree_mAnys
  1571. # ifdef __STDC__
  1572. (Tree_tTree pLayouts, Tree_tTree pNext)
  1573. # else
  1574. (pLayouts, pNext)
  1575. Tree_tTree pLayouts;
  1576. Tree_tTree pNext;
  1577. # endif
  1578. {
  1579.   LONGINT yyByteCount;
  1580.   Tree_tTree yyt;
  1581.  
  1582.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1583.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1584.     yyt = Tree_yyAlloc();
  1585.   }
  1586.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Anys]);
  1587.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1588.   yyt->U_1.V_1.Kind = Tree_Anys;
  1589.   {
  1590.     register Tree_yAnys *W_29 = &yyt->U_1.V_19.Anys;
  1591.  
  1592.     W_29->Layouts = pLayouts;
  1593.     W_29->Next = pNext;
  1594.   }
  1595.   return yyt;
  1596. }
  1597.  
  1598. Tree_tTree Tree_mLayouts
  1599. # ifdef __STDC__
  1600. ()
  1601. # else
  1602. ()
  1603. # endif
  1604. {
  1605.   LONGINT yyByteCount;
  1606.   Tree_tTree yyt;
  1607.  
  1608.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1609.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1610.     yyt = Tree_yyAlloc();
  1611.   }
  1612.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Layouts]);
  1613.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1614.   yyt->U_1.V_1.Kind = Tree_Layouts;
  1615.   return yyt;
  1616. }
  1617.  
  1618. Tree_tTree Tree_mNoLayout
  1619. # ifdef __STDC__
  1620. ()
  1621. # else
  1622. ()
  1623. # endif
  1624. {
  1625.   LONGINT yyByteCount;
  1626.   Tree_tTree yyt;
  1627.  
  1628.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1629.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1630.     yyt = Tree_yyAlloc();
  1631.   }
  1632.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_NoLayout]);
  1633.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1634.   yyt->U_1.V_1.Kind = Tree_NoLayout;
  1635.   return yyt;
  1636. }
  1637.  
  1638. Tree_tTree Tree_mLayoutAny
  1639. # ifdef __STDC__
  1640. (StringMem_tStringRef pCode, Tree_tTree pNext)
  1641. # else
  1642. (pCode, pNext)
  1643. StringMem_tStringRef pCode;
  1644. Tree_tTree pNext;
  1645. # endif
  1646. {
  1647.   LONGINT yyByteCount;
  1648.   Tree_tTree yyt;
  1649.  
  1650.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1651.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1652.     yyt = Tree_yyAlloc();
  1653.   }
  1654.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_LayoutAny]);
  1655.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1656.   yyt->U_1.V_1.Kind = Tree_LayoutAny;
  1657.   {
  1658.     register Tree_yLayoutAny *W_30 = &yyt->U_1.V_22.LayoutAny;
  1659.  
  1660.     W_30->Code = pCode;
  1661.     W_30->Next = pNext;
  1662.   }
  1663.   return yyt;
  1664. }
  1665.  
  1666. Tree_tTree Tree_mNames
  1667. # ifdef __STDC__
  1668. ()
  1669. # else
  1670. ()
  1671. # endif
  1672. {
  1673.   LONGINT yyByteCount;
  1674.   Tree_tTree yyt;
  1675.  
  1676.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1677.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1678.     yyt = Tree_yyAlloc();
  1679.   }
  1680.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Names]);
  1681.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1682.   yyt->U_1.V_1.Kind = Tree_Names;
  1683.   return yyt;
  1684. }
  1685.  
  1686. Tree_tTree Tree_mNoName
  1687. # ifdef __STDC__
  1688. ()
  1689. # else
  1690. ()
  1691. # endif
  1692. {
  1693.   LONGINT yyByteCount;
  1694.   Tree_tTree yyt;
  1695.  
  1696.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1697.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1698.     yyt = Tree_yyAlloc();
  1699.   }
  1700.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_NoName]);
  1701.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1702.   yyt->U_1.V_1.Kind = Tree_NoName;
  1703.   return yyt;
  1704. }
  1705.  
  1706. Tree_tTree Tree_mName
  1707. # ifdef __STDC__
  1708. (Idents_tIdent pName, Positions_tPosition pPos, Tree_tTree pNext)
  1709. # else
  1710. (pName, pPos, pNext)
  1711. Idents_tIdent pName;
  1712. Positions_tPosition pPos;
  1713. Tree_tTree pNext;
  1714. # endif
  1715. {
  1716.   LONGINT yyByteCount;
  1717.   Tree_tTree yyt;
  1718.  
  1719.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1720.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1721.     yyt = Tree_yyAlloc();
  1722.   }
  1723.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Name]);
  1724.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1725.   yyt->U_1.V_1.Kind = Tree_Name;
  1726.   {
  1727.     register Tree_yName *W_31 = &yyt->U_1.V_25.Name;
  1728.  
  1729.     W_31->Name = pName;
  1730.     W_31->Pos = pPos;
  1731.     W_31->Next = pNext;
  1732.   }
  1733.   return yyt;
  1734. }
  1735.  
  1736. Tree_tTree Tree_mAg
  1737. # ifdef __STDC__
  1738. (Idents_tIdent pName, Idents_tIdent pScannerName, Idents_tIdent pParserName, Tree_tTree pParserCodes, Idents_tIdent pTreeName, Tree_tTree pTreeCodes, Idents_tIdent pEvalName, Tree_tTree pEvalCodes, Tree_tTree pPrecs, Tree_tTree pProps, Tree_tTree pDecls, Tree_tTree pClasses, Tree_tTree pModules)
  1739. # else
  1740. (pName, pScannerName, pParserName, pParserCodes, pTreeName, pTreeCodes, pEvalName, pEvalCodes, pPrecs, pProps, pDecls, pClasses, pModules)
  1741. Idents_tIdent pName;
  1742. Idents_tIdent pScannerName;
  1743. Idents_tIdent pParserName;
  1744. Tree_tTree pParserCodes;
  1745. Idents_tIdent pTreeName;
  1746. Tree_tTree pTreeCodes;
  1747. Idents_tIdent pEvalName;
  1748. Tree_tTree pEvalCodes;
  1749. Tree_tTree pPrecs;
  1750. Tree_tTree pProps;
  1751. Tree_tTree pDecls;
  1752. Tree_tTree pClasses;
  1753. Tree_tTree pModules;
  1754. # endif
  1755. {
  1756.   LONGINT yyByteCount;
  1757.   Tree_tTree yyt;
  1758.  
  1759.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1760.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1761.     yyt = Tree_yyAlloc();
  1762.   }
  1763.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Ag]);
  1764.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1765.   yyt->U_1.V_1.Kind = Tree_Ag;
  1766.   {
  1767.     register Tree_yAg *W_32 = &yyt->U_1.V_26.Ag;
  1768.  
  1769.     W_32->Name = pName;
  1770.     W_32->ScannerName = pScannerName;
  1771.     W_32->ParserName = pParserName;
  1772.     W_32->ParserCodes = pParserCodes;
  1773.     W_32->TreeName = pTreeName;
  1774.     W_32->TreeCodes = pTreeCodes;
  1775.     W_32->EvalName = pEvalName;
  1776.     W_32->EvalCodes = pEvalCodes;
  1777.     W_32->Precs = pPrecs;
  1778.     W_32->Props = pProps;
  1779.     W_32->Decls = pDecls;
  1780.     W_32->Classes = pClasses;
  1781.     W_32->Modules = pModules;
  1782.     W_32->Properties = 0X0L;
  1783.   }
  1784.   return yyt;
  1785. }
  1786.  
  1787. Tree_tTree Tree_mPrecs
  1788. # ifdef __STDC__
  1789. ()
  1790. # else
  1791. ()
  1792. # endif
  1793. {
  1794.   LONGINT yyByteCount;
  1795.   Tree_tTree yyt;
  1796.  
  1797.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1798.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1799.     yyt = Tree_yyAlloc();
  1800.   }
  1801.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Precs]);
  1802.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1803.   yyt->U_1.V_1.Kind = Tree_Precs;
  1804.   return yyt;
  1805. }
  1806.  
  1807. Tree_tTree Tree_mNoPrec
  1808. # ifdef __STDC__
  1809. ()
  1810. # else
  1811. ()
  1812. # endif
  1813. {
  1814.   LONGINT yyByteCount;
  1815.   Tree_tTree yyt;
  1816.  
  1817.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1818.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1819.     yyt = Tree_yyAlloc();
  1820.   }
  1821.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_NoPrec]);
  1822.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1823.   yyt->U_1.V_1.Kind = Tree_NoPrec;
  1824.   return yyt;
  1825. }
  1826.  
  1827. Tree_tTree Tree_mPrec
  1828. # ifdef __STDC__
  1829. (Tree_tTree pNames, Tree_tTree pNext)
  1830. # else
  1831. (pNames, pNext)
  1832. Tree_tTree pNames;
  1833. Tree_tTree pNext;
  1834. # endif
  1835. {
  1836.   LONGINT yyByteCount;
  1837.   Tree_tTree yyt;
  1838.  
  1839.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1840.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1841.     yyt = Tree_yyAlloc();
  1842.   }
  1843.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Prec]);
  1844.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1845.   yyt->U_1.V_1.Kind = Tree_Prec;
  1846.   {
  1847.     register Tree_yPrec *W_33 = &yyt->U_1.V_29.Prec;
  1848.  
  1849.     W_33->Names = pNames;
  1850.     W_33->Next = pNext;
  1851.   }
  1852.   return yyt;
  1853. }
  1854.  
  1855. Tree_tTree Tree_mLeftAssoc
  1856. # ifdef __STDC__
  1857. (Tree_tTree pNames, Tree_tTree pNext)
  1858. # else
  1859. (pNames, pNext)
  1860. Tree_tTree pNames;
  1861. Tree_tTree pNext;
  1862. # endif
  1863. {
  1864.   LONGINT yyByteCount;
  1865.   Tree_tTree yyt;
  1866.  
  1867.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1868.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1869.     yyt = Tree_yyAlloc();
  1870.   }
  1871.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_LeftAssoc]);
  1872.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1873.   yyt->U_1.V_1.Kind = Tree_LeftAssoc;
  1874.   {
  1875.     register Tree_yLeftAssoc *W_34 = &yyt->U_1.V_30.LeftAssoc;
  1876.  
  1877.     W_34->Names = pNames;
  1878.     W_34->Next = pNext;
  1879.   }
  1880.   return yyt;
  1881. }
  1882.  
  1883. Tree_tTree Tree_mRightAssoc
  1884. # ifdef __STDC__
  1885. (Tree_tTree pNames, Tree_tTree pNext)
  1886. # else
  1887. (pNames, pNext)
  1888. Tree_tTree pNames;
  1889. Tree_tTree pNext;
  1890. # endif
  1891. {
  1892.   LONGINT yyByteCount;
  1893.   Tree_tTree yyt;
  1894.  
  1895.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1896.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1897.     yyt = Tree_yyAlloc();
  1898.   }
  1899.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_RightAssoc]);
  1900.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1901.   yyt->U_1.V_1.Kind = Tree_RightAssoc;
  1902.   {
  1903.     register Tree_yRightAssoc *W_35 = &yyt->U_1.V_31.RightAssoc;
  1904.  
  1905.     W_35->Names = pNames;
  1906.     W_35->Next = pNext;
  1907.   }
  1908.   return yyt;
  1909. }
  1910.  
  1911. Tree_tTree Tree_mNonAssoc
  1912. # ifdef __STDC__
  1913. (Tree_tTree pNames, Tree_tTree pNext)
  1914. # else
  1915. (pNames, pNext)
  1916. Tree_tTree pNames;
  1917. Tree_tTree pNext;
  1918. # endif
  1919. {
  1920.   LONGINT yyByteCount;
  1921.   Tree_tTree yyt;
  1922.  
  1923.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1924.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1925.     yyt = Tree_yyAlloc();
  1926.   }
  1927.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_NonAssoc]);
  1928.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1929.   yyt->U_1.V_1.Kind = Tree_NonAssoc;
  1930.   {
  1931.     register Tree_yNonAssoc *W_36 = &yyt->U_1.V_32.NonAssoc;
  1932.  
  1933.     W_36->Names = pNames;
  1934.     W_36->Next = pNext;
  1935.   }
  1936.   return yyt;
  1937. }
  1938.  
  1939. Tree_tTree Tree_mActions
  1940. # ifdef __STDC__
  1941. ()
  1942. # else
  1943. ()
  1944. # endif
  1945. {
  1946.   LONGINT yyByteCount;
  1947.   Tree_tTree yyt;
  1948.  
  1949.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1950.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1951.     yyt = Tree_yyAlloc();
  1952.   }
  1953.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Actions]);
  1954.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1955.   yyt->U_1.V_1.Kind = Tree_Actions;
  1956.   return yyt;
  1957. }
  1958.  
  1959. Tree_tTree Tree_mNoAction
  1960. # ifdef __STDC__
  1961. ()
  1962. # else
  1963. ()
  1964. # endif
  1965. {
  1966.   LONGINT yyByteCount;
  1967.   Tree_tTree yyt;
  1968.  
  1969.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1970.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1971.     yyt = Tree_yyAlloc();
  1972.   }
  1973.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_NoAction]);
  1974.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1975.   yyt->U_1.V_1.Kind = Tree_NoAction;
  1976.   return yyt;
  1977. }
  1978.  
  1979. Tree_tTree Tree_mAction
  1980. # ifdef __STDC__
  1981. (Tree_tTree pNext, Positions_tPosition pPos)
  1982. # else
  1983. (pNext, pPos)
  1984. Tree_tTree pNext;
  1985. Positions_tPosition pPos;
  1986. # endif
  1987. {
  1988.   LONGINT yyByteCount;
  1989.   Tree_tTree yyt;
  1990.  
  1991.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1992.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1993.     yyt = Tree_yyAlloc();
  1994.   }
  1995.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Action]);
  1996.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1997.   yyt->U_1.V_1.Kind = Tree_Action;
  1998.   {
  1999.     register Tree_yAction *W_37 = &yyt->U_1.V_35.Action;
  2000.  
  2001.     W_37->Next = pNext;
  2002.     W_37->Pos = pPos;
  2003.   }
  2004.   return yyt;
  2005. }
  2006.  
  2007. Tree_tTree Tree_mAssign
  2008. # ifdef __STDC__
  2009. (Tree_tTree pNext, Positions_tPosition pPos, Tree_tTree pResults, Tree_tTree pArguments)
  2010. # else
  2011. (pNext, pPos, pResults, pArguments)
  2012. Tree_tTree pNext;
  2013. Positions_tPosition pPos;
  2014. Tree_tTree pResults;
  2015. Tree_tTree pArguments;
  2016. # endif
  2017. {
  2018.   LONGINT yyByteCount;
  2019.   Tree_tTree yyt;
  2020.  
  2021.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2022.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2023.     yyt = Tree_yyAlloc();
  2024.   }
  2025.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Assign]);
  2026.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2027.   yyt->U_1.V_1.Kind = Tree_Assign;
  2028.   {
  2029.     register Tree_yAssign *W_38 = &yyt->U_1.V_36.Assign;
  2030.  
  2031.     W_38->Next = pNext;
  2032.     W_38->Pos = pPos;
  2033.     W_38->Results = pResults;
  2034.     W_38->Arguments = pArguments;
  2035.   }
  2036.   return yyt;
  2037. }
  2038.  
  2039. Tree_tTree Tree_mCopy
  2040. # ifdef __STDC__
  2041. (Tree_tTree pNext, Positions_tPosition pPos, Tree_tTree pResults, Tree_tTree pArguments)
  2042. # else
  2043. (pNext, pPos, pResults, pArguments)
  2044. Tree_tTree pNext;
  2045. Positions_tPosition pPos;
  2046. Tree_tTree pResults;
  2047. Tree_tTree pArguments;
  2048. # endif
  2049. {
  2050.   LONGINT yyByteCount;
  2051.   Tree_tTree yyt;
  2052.  
  2053.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2054.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2055.     yyt = Tree_yyAlloc();
  2056.   }
  2057.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Copy]);
  2058.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2059.   yyt->U_1.V_1.Kind = Tree_Copy;
  2060.   {
  2061.     register Tree_yCopy *W_39 = &yyt->U_1.V_37.Copy;
  2062.  
  2063.     W_39->Next = pNext;
  2064.     W_39->Pos = pPos;
  2065.     W_39->Results = pResults;
  2066.     W_39->Arguments = pArguments;
  2067.   }
  2068.   return yyt;
  2069. }
  2070.  
  2071. Tree_tTree Tree_mTargetCode
  2072. # ifdef __STDC__
  2073. (Tree_tTree pNext, Positions_tPosition pPos, Tree_tTree pResults, Tree_tTree pCode)
  2074. # else
  2075. (pNext, pPos, pResults, pCode)
  2076. Tree_tTree pNext;
  2077. Positions_tPosition pPos;
  2078. Tree_tTree pResults;
  2079. Tree_tTree pCode;
  2080. # endif
  2081. {
  2082.   LONGINT yyByteCount;
  2083.   Tree_tTree yyt;
  2084.  
  2085.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2086.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2087.     yyt = Tree_yyAlloc();
  2088.   }
  2089.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_TargetCode]);
  2090.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2091.   yyt->U_1.V_1.Kind = Tree_TargetCode;
  2092.   {
  2093.     register Tree_yTargetCode *W_40 = &yyt->U_1.V_38.TargetCode;
  2094.  
  2095.     W_40->Next = pNext;
  2096.     W_40->Pos = pPos;
  2097.     W_40->Results = pResults;
  2098.     W_40->Code = pCode;
  2099.   }
  2100.   return yyt;
  2101. }
  2102.  
  2103. Tree_tTree Tree_mOrder
  2104. # ifdef __STDC__
  2105. (Tree_tTree pNext, Positions_tPosition pPos, Tree_tTree pResults, Tree_tTree pArguments)
  2106. # else
  2107. (pNext, pPos, pResults, pArguments)
  2108. Tree_tTree pNext;
  2109. Positions_tPosition pPos;
  2110. Tree_tTree pResults;
  2111. Tree_tTree pArguments;
  2112. # endif
  2113. {
  2114.   LONGINT yyByteCount;
  2115.   Tree_tTree yyt;
  2116.  
  2117.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2118.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2119.     yyt = Tree_yyAlloc();
  2120.   }
  2121.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Order]);
  2122.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2123.   yyt->U_1.V_1.Kind = Tree_Order;
  2124.   {
  2125.     register Tree_yOrder *W_41 = &yyt->U_1.V_39.Order;
  2126.  
  2127.     W_41->Next = pNext;
  2128.     W_41->Pos = pPos;
  2129.     W_41->Results = pResults;
  2130.     W_41->Arguments = pArguments;
  2131.   }
  2132.   return yyt;
  2133. }
  2134.  
  2135. Tree_tTree Tree_mCheck
  2136. # ifdef __STDC__
  2137. (Tree_tTree pNext, Positions_tPosition pPos, Tree_tTree pCondition, Tree_tTree pStatement, Tree_tTree pActions)
  2138. # else
  2139. (pNext, pPos, pCondition, pStatement, pActions)
  2140. Tree_tTree pNext;
  2141. Positions_tPosition pPos;
  2142. Tree_tTree pCondition;
  2143. Tree_tTree pStatement;
  2144. Tree_tTree pActions;
  2145. # endif
  2146. {
  2147.   LONGINT yyByteCount;
  2148.   Tree_tTree yyt;
  2149.  
  2150.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2151.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2152.     yyt = Tree_yyAlloc();
  2153.   }
  2154.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Check]);
  2155.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2156.   yyt->U_1.V_1.Kind = Tree_Check;
  2157.   {
  2158.     register Tree_yCheck *W_42 = &yyt->U_1.V_40.Check;
  2159.  
  2160.     W_42->Next = pNext;
  2161.     W_42->Pos = pPos;
  2162.     W_42->Condition = pCondition;
  2163.     W_42->Statement = pStatement;
  2164.     W_42->Actions = pActions;
  2165.     W_42->Results = Tree_NoTree;
  2166.   }
  2167.   return yyt;
  2168. }
  2169.  
  2170. Tree_tTree Tree_mModules
  2171. # ifdef __STDC__
  2172. ()
  2173. # else
  2174. ()
  2175. # endif
  2176. {
  2177.   LONGINT yyByteCount;
  2178.   Tree_tTree yyt;
  2179.  
  2180.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2181.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2182.     yyt = Tree_yyAlloc();
  2183.   }
  2184.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Modules]);
  2185.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2186.   yyt->U_1.V_1.Kind = Tree_Modules;
  2187.   return yyt;
  2188. }
  2189.  
  2190. Tree_tTree Tree_mNoModule
  2191. # ifdef __STDC__
  2192. ()
  2193. # else
  2194. ()
  2195. # endif
  2196. {
  2197.   LONGINT yyByteCount;
  2198.   Tree_tTree yyt;
  2199.  
  2200.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2201.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2202.     yyt = Tree_yyAlloc();
  2203.   }
  2204.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_NoModule]);
  2205.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2206.   yyt->U_1.V_1.Kind = Tree_NoModule;
  2207.   return yyt;
  2208. }
  2209.  
  2210. Tree_tTree Tree_mModule
  2211. # ifdef __STDC__
  2212. (Idents_tIdent pName, Tree_tTree pParserCodes, Tree_tTree pTreeCodes, Tree_tTree pEvalCodes, Tree_tTree pProps, Tree_tTree pDecls, Tree_tTree pClasses, Tree_tTree pNext)
  2213. # else
  2214. (pName, pParserCodes, pTreeCodes, pEvalCodes, pProps, pDecls, pClasses, pNext)
  2215. Idents_tIdent pName;
  2216. Tree_tTree pParserCodes;
  2217. Tree_tTree pTreeCodes;
  2218. Tree_tTree pEvalCodes;
  2219. Tree_tTree pProps;
  2220. Tree_tTree pDecls;
  2221. Tree_tTree pClasses;
  2222. Tree_tTree pNext;
  2223. # endif
  2224. {
  2225.   LONGINT yyByteCount;
  2226.   Tree_tTree yyt;
  2227.  
  2228.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2229.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2230.     yyt = Tree_yyAlloc();
  2231.   }
  2232.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Module]);
  2233.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2234.   yyt->U_1.V_1.Kind = Tree_Module;
  2235.   {
  2236.     register Tree_yModule *W_43 = &yyt->U_1.V_43.Module;
  2237.  
  2238.     W_43->Name = pName;
  2239.     W_43->ParserCodes = pParserCodes;
  2240.     W_43->TreeCodes = pTreeCodes;
  2241.     W_43->EvalCodes = pEvalCodes;
  2242.     W_43->Props = pProps;
  2243.     W_43->Decls = pDecls;
  2244.     W_43->Classes = pClasses;
  2245.     W_43->Next = pNext;
  2246.     W_43->Properties = 0X0L;
  2247.   }
  2248.   return yyt;
  2249. }
  2250.  
  2251. Tree_tTree Tree_mProps
  2252. # ifdef __STDC__
  2253. ()
  2254. # else
  2255. ()
  2256. # endif
  2257. {
  2258.   LONGINT yyByteCount;
  2259.   Tree_tTree yyt;
  2260.  
  2261.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2262.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2263.     yyt = Tree_yyAlloc();
  2264.   }
  2265.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Props]);
  2266.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2267.   yyt->U_1.V_1.Kind = Tree_Props;
  2268.   return yyt;
  2269. }
  2270.  
  2271. Tree_tTree Tree_mNoProp
  2272. # ifdef __STDC__
  2273. ()
  2274. # else
  2275. ()
  2276. # endif
  2277. {
  2278.   LONGINT yyByteCount;
  2279.   Tree_tTree yyt;
  2280.  
  2281.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2282.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2283.     yyt = Tree_yyAlloc();
  2284.   }
  2285.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_NoProp]);
  2286.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2287.   yyt->U_1.V_1.Kind = Tree_NoProp;
  2288.   return yyt;
  2289. }
  2290.  
  2291. Tree_tTree Tree_mProp
  2292. # ifdef __STDC__
  2293. (BITSET pProperties, Tree_tTree pNames, Tree_tTree pNext)
  2294. # else
  2295. (pProperties, pNames, pNext)
  2296. BITSET pProperties;
  2297. Tree_tTree pNames;
  2298. Tree_tTree pNext;
  2299. # endif
  2300. {
  2301.   LONGINT yyByteCount;
  2302.   Tree_tTree yyt;
  2303.  
  2304.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2305.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2306.     yyt = Tree_yyAlloc();
  2307.   }
  2308.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Prop]);
  2309.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2310.   yyt->U_1.V_1.Kind = Tree_Prop;
  2311.   {
  2312.     register Tree_yProp *W_44 = &yyt->U_1.V_46.Prop;
  2313.  
  2314.     W_44->Properties = pProperties;
  2315.     W_44->Names = pNames;
  2316.     W_44->Next = pNext;
  2317.   }
  2318.   return yyt;
  2319. }
  2320.  
  2321. Tree_tTree Tree_mSelect
  2322. # ifdef __STDC__
  2323. (Tree_tTree pNames, Tree_tTree pNext)
  2324. # else
  2325. (pNames, pNext)
  2326. Tree_tTree pNames;
  2327. Tree_tTree pNext;
  2328. # endif
  2329. {
  2330.   LONGINT yyByteCount;
  2331.   Tree_tTree yyt;
  2332.  
  2333.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2334.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2335.     yyt = Tree_yyAlloc();
  2336.   }
  2337.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Select]);
  2338.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2339.   yyt->U_1.V_1.Kind = Tree_Select;
  2340.   {
  2341.     register Tree_ySelect *W_45 = &yyt->U_1.V_47.Select;
  2342.  
  2343.     W_45->Names = pNames;
  2344.     W_45->Next = pNext;
  2345.   }
  2346.   return yyt;
  2347. }
  2348.  
  2349. Tree_tTree Tree_mDecls
  2350. # ifdef __STDC__
  2351. ()
  2352. # else
  2353. ()
  2354. # endif
  2355. {
  2356.   LONGINT yyByteCount;
  2357.   Tree_tTree yyt;
  2358.  
  2359.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2360.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2361.     yyt = Tree_yyAlloc();
  2362.   }
  2363.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Decls]);
  2364.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2365.   yyt->U_1.V_1.Kind = Tree_Decls;
  2366.   return yyt;
  2367. }
  2368.  
  2369. Tree_tTree Tree_mNoDecl
  2370. # ifdef __STDC__
  2371. ()
  2372. # else
  2373. ()
  2374. # endif
  2375. {
  2376.   LONGINT yyByteCount;
  2377.   Tree_tTree yyt;
  2378.  
  2379.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2380.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2381.     yyt = Tree_yyAlloc();
  2382.   }
  2383.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_NoDecl]);
  2384.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2385.   yyt->U_1.V_1.Kind = Tree_NoDecl;
  2386.   return yyt;
  2387. }
  2388.  
  2389. Tree_tTree Tree_mDecl
  2390. # ifdef __STDC__
  2391. (Tree_tTree pNames, Tree_tTree pAttributes, Tree_tClassProperties pProperties, Tree_tTree pNext)
  2392. # else
  2393. (pNames, pAttributes, pProperties, pNext)
  2394. Tree_tTree pNames;
  2395. Tree_tTree pAttributes;
  2396. Tree_tClassProperties pProperties;
  2397. Tree_tTree pNext;
  2398. # endif
  2399. {
  2400.   LONGINT yyByteCount;
  2401.   Tree_tTree yyt;
  2402.  
  2403.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2404.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2405.     yyt = Tree_yyAlloc();
  2406.   }
  2407.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Decl]);
  2408.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2409.   yyt->U_1.V_1.Kind = Tree_Decl;
  2410.   {
  2411.     register Tree_yDecl *W_46 = &yyt->U_1.V_50.Decl;
  2412.  
  2413.     W_46->Names = pNames;
  2414.     W_46->Attributes = pAttributes;
  2415.     W_46->Properties = pProperties;
  2416.     W_46->Next = pNext;
  2417.   }
  2418.   return yyt;
  2419. }
  2420.  
  2421. static void yyWriteNl
  2422. # ifdef __STDC__
  2423. ()
  2424. # else
  2425. ()
  2426. # endif
  2427. {
  2428.   IO_WriteNl(yyf);
  2429. }
  2430.  
  2431. static void yyWriteSelector
  2432. # ifdef __STDC__
  2433. (CHAR yys[], LONGCARD O_1)
  2434. # else
  2435. (yys, O_1)
  2436. CHAR yys[];
  2437. LONGCARD O_1;
  2438. # endif
  2439. {
  2440.   OPEN_ARRAY_LOCALS
  2441.  
  2442.   ALLOC_OPEN_ARRAYS(O_1 * sizeof(CHAR), 1)
  2443.   COPY_OPEN_ARRAY(yys, O_1, CHAR)
  2444.   IO_WriteS(yyf, yys, O_1);
  2445.   Layout_WriteSpaces(yyf, 15 - (INTEGER)(O_1 - 1));
  2446.   IO_WriteS(yyf, (STRING)" = ", 3L);
  2447.   FREE_OPEN_ARRAYS
  2448. }
  2449.  
  2450. static void yyWriteHex
  2451. # ifdef __STDC__
  2452. (BYTE yyx[], LONGCARD O_2)
  2453. # else
  2454. (yyx, O_2)
  2455. BYTE yyx[];
  2456. LONGCARD O_2;
  2457. # endif
  2458. {
  2459.   INTEGER yyi;
  2460.  
  2461.   {
  2462.     LONGINT B_13 = 0, B_14 = (INTEGER)(O_2 - 1);
  2463.  
  2464.     if (B_13 <= B_14)
  2465.       for (yyi = B_13;; yyi += 1) {
  2466.         IO_WriteN(yyf, ORD((CHAR)yyx[yyi]), 2L, 16L);
  2467.         IO_WriteC(yyf, ' ');
  2468.         if (yyi >= B_14) break;
  2469.       }
  2470.   }
  2471. }
  2472.  
  2473. static void yyWriteAdr
  2474. # ifdef __STDC__
  2475. (Tree_tTree yyt)
  2476. # else
  2477. (yyt)
  2478. Tree_tTree yyt;
  2479. # endif
  2480. {
  2481.   if (yyt == Tree_NoTree) {
  2482.     IO_WriteS(yyf, (STRING)"NoTree", 6L);
  2483.   } else {
  2484.     yyWriteHex((WORD *)&yyt, (LONGCARD)sizeof(yyt));
  2485.   }
  2486.   yyWriteNl();
  2487. }
  2488.  
  2489. static void yWriteNodeClass
  2490. # ifdef __STDC__
  2491. (Tree_tTree yyt)
  2492. # else
  2493. (yyt)
  2494. Tree_tTree yyt;
  2495. # endif
  2496. {
  2497.   yyWriteSelector((STRING)"Name", 4L);
  2498.   Idents_WriteIdent(yyf, yyt->U_1.V_5.Class.Name);
  2499.   yyWriteNl();
  2500.   yyWriteSelector((STRING)"Properties", 10L);
  2501.   Tree_WriteClassProperties(yyf, yyt->U_1.V_5.Class.Properties);
  2502.   yyWriteNl();
  2503.   yyWriteSelector((STRING)"Attributes", 10L);
  2504.   yyWriteAdr(yyt->U_1.V_5.Class.Attributes);
  2505.   yyWriteSelector((STRING)"Extensions", 10L);
  2506.   yyWriteAdr(yyt->U_1.V_5.Class.Extensions);
  2507.   yyWriteSelector((STRING)"Next", 4L);
  2508.   yyWriteAdr(yyt->U_1.V_5.Class.Next);
  2509.   yyWriteSelector((STRING)"BaseClass", 9L);
  2510.   yyWriteAdr(yyt->U_1.V_5.Class.BaseClass);
  2511.   yyWriteSelector((STRING)"Selector", 8L);
  2512.   Idents_WriteIdent(yyf, yyt->U_1.V_5.Class.Selector);
  2513.   yyWriteNl();
  2514.   yyWriteSelector((STRING)"Pos", 3L);
  2515.   Positions_WritePosition(yyf, yyt->U_1.V_5.Class.Pos);
  2516.   yyWriteNl();
  2517.   yyWriteSelector((STRING)"Code", 4L);
  2518.   IO_WriteI(yyf, (LONGINT)yyt->U_1.V_5.Class.Code, 0L);
  2519.   yyWriteNl();
  2520.   yyWriteSelector((STRING)"Prec", 4L);
  2521.   Idents_WriteIdent(yyf, yyt->U_1.V_5.Class.Prec);
  2522.   yyWriteNl();
  2523.   yyWriteSelector((STRING)"Names", 5L);
  2524.   yyWriteAdr(yyt->U_1.V_5.Class.Names);
  2525.   yyWriteSelector((STRING)"AttrCount", 9L);
  2526.   IO_WriteI(yyf, (LONGINT)yyt->U_1.V_5.Class.AttrCount, 0L);
  2527.   yyWriteNl();
  2528.   yyWriteSelector((STRING)"InstCount", 9L);
  2529.   IO_WriteI(yyf, (LONGINT)yyt->U_1.V_5.Class.InstCount, 0L);
  2530.   yyWriteNl();
  2531.   yyWriteSelector((STRING)"Instance", 8L);
  2532.   yyWriteHex((WORD *)&yyt->U_1.V_5.Class.Instance, (LONGCARD)sizeof(yyt->U_1.V_5.Class.Instance));
  2533.   yyWriteNl();
  2534.   yyWriteSelector((STRING)"DP", 2L);
  2535.   Relations_WriteRelation(yyf, yyt->U_1.V_5.Class.DP);
  2536.   yyWriteNl();
  2537.   yyWriteSelector((STRING)"SNC", 3L);
  2538.   Relations_WriteRelation(yyf, yyt->U_1.V_5.Class.SNC);
  2539.   yyWriteNl();
  2540.   yyWriteSelector((STRING)"DNC", 3L);
  2541.   Relations_WriteRelation(yyf, yyt->U_1.V_5.Class.DNC);
  2542.   yyWriteNl();
  2543.   yyWriteSelector((STRING)"OAG", 3L);
  2544.   Relations_WriteRelation(yyf, yyt->U_1.V_5.Class.OAG);
  2545.   yyWriteNl();
  2546.   yyWriteSelector((STRING)"Part", 4L);
  2547.   Relations_WriteRelation(yyf, yyt->U_1.V_5.Class.Part);
  2548.   yyWriteNl();
  2549.   yyWriteSelector((STRING)"Index", 5L);
  2550.   IO_WriteI(yyf, (LONGINT)yyt->U_1.V_5.Class.Index, 0L);
  2551.   yyWriteNl();
  2552.   yyWriteSelector((STRING)"Visits", 6L);
  2553.   IO_WriteI(yyf, (LONGINT)yyt->U_1.V_5.Class.Visits, 0L);
  2554.   yyWriteNl();
  2555.   yyWriteSelector((STRING)"Users", 5L);
  2556.   Sets_WriteSet(yyf, yyt->U_1.V_5.Class.Users);
  2557.   yyWriteNl();
  2558.   yyWriteSelector((STRING)"Generated", 9L);
  2559.   IO_WriteI(yyf, (LONGINT)yyt->U_1.V_5.Class.Generated, 0L);
  2560.   yyWriteNl();
  2561.   yyWriteSelector((STRING)"BitCount", 8L);
  2562.   IO_WriteI(yyf, (LONGINT)yyt->U_1.V_5.Class.BitCount, 0L);
  2563.   yyWriteNl();
  2564.   yyWriteSelector((STRING)"BitIndex", 8L);
  2565.   yyWriteHex((WORD *)&yyt->U_1.V_5.Class.BitIndex, (LONGCARD)sizeof(yyt->U_1.V_5.Class.BitIndex));
  2566.   yyWriteNl();
  2567.   yyWriteSelector((STRING)"D", 1L);
  2568.   yyWriteHex((WORD *)&yyt->U_1.V_5.Class.D, (LONGCARD)sizeof(yyt->U_1.V_5.Class.D));
  2569.   yyWriteNl();
  2570. }
  2571.  
  2572. static void yWriteNodeAttrOrAction
  2573. # ifdef __STDC__
  2574. (Tree_tTree yyt)
  2575. # else
  2576. (yyt)
  2577. Tree_tTree yyt;
  2578. # endif
  2579. {
  2580.   yyWriteSelector((STRING)"Next", 4L);
  2581.   yyWriteAdr(yyt->U_1.V_8.AttrOrAction.Next);
  2582.   yyWriteSelector((STRING)"Item", 4L);
  2583.   IO_WriteI(yyf, (LONGINT)yyt->U_1.V_8.AttrOrAction.Item, 0L);
  2584.   yyWriteNl();
  2585. }
  2586.  
  2587. static void yWriteNodeChild
  2588. # ifdef __STDC__
  2589. (Tree_tTree yyt)
  2590. # else
  2591. (yyt)
  2592. Tree_tTree yyt;
  2593. # endif
  2594. {
  2595.   yWriteNodeAttrOrAction(yyt);
  2596.   yyWriteSelector((STRING)"Name", 4L);
  2597.   Idents_WriteIdent(yyf, yyt->U_1.V_9.Child.Name);
  2598.   yyWriteNl();
  2599.   yyWriteSelector((STRING)"Type", 4L);
  2600.   Idents_WriteIdent(yyf, yyt->U_1.V_9.Child.Type);
  2601.   yyWriteNl();
  2602.   yyWriteSelector((STRING)"Properties", 10L);
  2603.   Tree_WriteAttrProperties(yyf, yyt->U_1.V_9.Child.Properties);
  2604.   yyWriteNl();
  2605.   yyWriteSelector((STRING)"Pos", 3L);
  2606.   Positions_WritePosition(yyf, yyt->U_1.V_9.Child.Pos);
  2607.   yyWriteNl();
  2608.   yyWriteSelector((STRING)"AttrIndex", 9L);
  2609.   IO_WriteI(yyf, (LONGINT)yyt->U_1.V_9.Child.AttrIndex, 0L);
  2610.   yyWriteNl();
  2611.   yyWriteSelector((STRING)"Partition", 9L);
  2612.   IO_WriteI(yyf, (LONGINT)yyt->U_1.V_9.Child.Partition, 0L);
  2613.   yyWriteNl();
  2614.   yyWriteSelector((STRING)"Usage", 5L);
  2615.   yyWriteHex((WORD *)&yyt->U_1.V_9.Child.Usage, (LONGCARD)sizeof(yyt->U_1.V_9.Child.Usage));
  2616.   yyWriteNl();
  2617.   yyWriteSelector((STRING)"InstOffset", 10L);
  2618.   IO_WriteI(yyf, (LONGINT)yyt->U_1.V_9.Child.InstOffset, 0L);
  2619.   yyWriteNl();
  2620.   yyWriteSelector((STRING)"Class", 5L);
  2621.   yyWriteHex((WORD *)&yyt->U_1.V_9.Child.Class, (LONGCARD)sizeof(yyt->U_1.V_9.Child.Class));
  2622.   yyWriteNl();
  2623.   yyWriteSelector((STRING)"ParsIndex", 9L);
  2624.   IO_WriteI(yyf, (LONGINT)yyt->U_1.V_9.Child.ParsIndex, 0L);
  2625.   yyWriteNl();
  2626.   yyWriteSelector((STRING)"BitOffset", 9L);
  2627.   IO_WriteI(yyf, (LONGINT)yyt->U_1.V_9.Child.BitOffset, 0L);
  2628.   yyWriteNl();
  2629. }
  2630.  
  2631. static void yWriteNodeAttribute
  2632. # ifdef __STDC__
  2633. (Tree_tTree yyt)
  2634. # else
  2635. (yyt)
  2636. Tree_tTree yyt;
  2637. # endif
  2638. {
  2639.   yWriteNodeAttrOrAction(yyt);
  2640.   yyWriteSelector((STRING)"Name", 4L);
  2641.   Idents_WriteIdent(yyf, yyt->U_1.V_10.Attribute.Name);
  2642.   yyWriteNl();
  2643.   yyWriteSelector((STRING)"Type", 4L);
  2644.   Idents_WriteIdent(yyf, yyt->U_1.V_10.Attribute.Type);
  2645.   yyWriteNl();
  2646.   yyWriteSelector((STRING)"Properties", 10L);
  2647.   Tree_WriteAttrProperties(yyf, yyt->U_1.V_10.Attribute.Properties);
  2648.   yyWriteNl();
  2649.   yyWriteSelector((STRING)"Pos", 3L);
  2650.   Positions_WritePosition(yyf, yyt->U_1.V_10.Attribute.Pos);
  2651.   yyWriteNl();
  2652.   yyWriteSelector((STRING)"AttrIndex", 9L);
  2653.   IO_WriteI(yyf, (LONGINT)yyt->U_1.V_10.Attribute.AttrIndex, 0L);
  2654.   yyWriteNl();
  2655.   yyWriteSelector((STRING)"Partition", 9L);
  2656.   IO_WriteI(yyf, (LONGINT)yyt->U_1.V_10.Attribute.Partition, 0L);
  2657.   yyWriteNl();
  2658.   yyWriteSelector((STRING)"Usage", 5L);
  2659.   yyWriteHex((WORD *)&yyt->U_1.V_10.Attribute.Usage, (LONGCARD)sizeof(yyt->U_1.V_10.Attribute.Usage));
  2660.   yyWriteNl();
  2661. }
  2662.  
  2663. static void yWriteNodeActionPart
  2664. # ifdef __STDC__
  2665. (Tree_tTree yyt)
  2666. # else
  2667. (yyt)
  2668. Tree_tTree yyt;
  2669. # endif
  2670. {
  2671.   yWriteNodeAttrOrAction(yyt);
  2672.   yyWriteSelector((STRING)"Actions", 7L);
  2673.   yyWriteAdr(yyt->U_1.V_11.ActionPart.Actions);
  2674.   yyWriteSelector((STRING)"Name", 4L);
  2675.   IO_WriteI(yyf, (LONGINT)yyt->U_1.V_11.ActionPart.Name, 0L);
  2676.   yyWriteNl();
  2677.   yyWriteSelector((STRING)"ParsIndex", 9L);
  2678.   IO_WriteI(yyf, (LONGINT)yyt->U_1.V_11.ActionPart.ParsIndex, 0L);
  2679.   yyWriteNl();
  2680.   yyWriteSelector((STRING)"Properties", 10L);
  2681.   yyWriteHex((WORD *)&yyt->U_1.V_11.ActionPart.Properties, (LONGCARD)sizeof(yyt->U_1.V_11.ActionPart.Properties));
  2682.   yyWriteNl();
  2683. }
  2684.  
  2685. static void yWriteNodeCodes
  2686. # ifdef __STDC__
  2687. (Tree_tTree yyt)
  2688. # else
  2689. (yyt)
  2690. Tree_tTree yyt;
  2691. # endif
  2692. {
  2693.   yyWriteSelector((STRING)"Export", 6L);
  2694.   Texts_WriteText(yyf, yyt->U_1.V_12.Codes.Export);
  2695.   yyWriteNl();
  2696.   yyWriteSelector((STRING)"Import", 6L);
  2697.   Texts_WriteText(yyf, yyt->U_1.V_12.Codes.Import);
  2698.   yyWriteNl();
  2699.   yyWriteSelector((STRING)"Global", 6L);
  2700.   Texts_WriteText(yyf, yyt->U_1.V_12.Codes.Global);
  2701.   yyWriteNl();
  2702.   yyWriteSelector((STRING)"Local", 5L);
  2703.   Texts_WriteText(yyf, yyt->U_1.V_12.Codes.Local);
  2704.   yyWriteNl();
  2705.   yyWriteSelector((STRING)"Begin", 5L);
  2706.   Texts_WriteText(yyf, yyt->U_1.V_12.Codes.Begin);
  2707.   yyWriteNl();
  2708.   yyWriteSelector((STRING)"Close", 5L);
  2709.   Texts_WriteText(yyf, yyt->U_1.V_12.Codes.Close);
  2710.   yyWriteNl();
  2711.   yyWriteSelector((STRING)"ExportLine", 10L);
  2712.   Positions_WritePosition(yyf, yyt->U_1.V_12.Codes.ExportLine);
  2713.   yyWriteNl();
  2714.   yyWriteSelector((STRING)"ImportLine", 10L);
  2715.   Positions_WritePosition(yyf, yyt->U_1.V_12.Codes.ImportLine);
  2716.   yyWriteNl();
  2717.   yyWriteSelector((STRING)"GlobalLine", 10L);
  2718.   Positions_WritePosition(yyf, yyt->U_1.V_12.Codes.GlobalLine);
  2719.   yyWriteNl();
  2720.   yyWriteSelector((STRING)"LocalLine", 9L);
  2721.   Positions_WritePosition(yyf, yyt->U_1.V_12.Codes.LocalLine);
  2722.   yyWriteNl();
  2723.   yyWriteSelector((STRING)"BeginLine", 9L);
  2724.   Positions_WritePosition(yyf, yyt->U_1.V_12.Codes.BeginLine);
  2725.   yyWriteNl();
  2726.   yyWriteSelector((STRING)"CloseLine", 9L);
  2727.   Positions_WritePosition(yyf, yyt->U_1.V_12.Codes.CloseLine);
  2728.   yyWriteNl();
  2729. }
  2730.  
  2731. static void yWriteNodeDesignator
  2732. # ifdef __STDC__
  2733. (Tree_tTree yyt)
  2734. # else
  2735. (yyt)
  2736. Tree_tTree yyt;
  2737. # endif
  2738. {
  2739.   yyWriteSelector((STRING)"Selector", 8L);
  2740.   Idents_WriteIdent(yyf, yyt->U_1.V_15.Designator.Selector);
  2741.   yyWriteNl();
  2742.   yyWriteSelector((STRING)"Attribute", 9L);
  2743.   Idents_WriteIdent(yyf, yyt->U_1.V_15.Designator.Attribute);
  2744.   yyWriteNl();
  2745.   yyWriteSelector((STRING)"Pos", 3L);
  2746.   Positions_WritePosition(yyf, yyt->U_1.V_15.Designator.Pos);
  2747.   yyWriteNl();
  2748.   yyWriteSelector((STRING)"Next", 4L);
  2749.   yyWriteAdr(yyt->U_1.V_15.Designator.Next);
  2750. }
  2751.  
  2752. static void yWriteNodeIdent
  2753. # ifdef __STDC__
  2754. (Tree_tTree yyt)
  2755. # else
  2756. (yyt)
  2757. Tree_tTree yyt;
  2758. # endif
  2759. {
  2760.   yyWriteSelector((STRING)"Attribute", 9L);
  2761.   Idents_WriteIdent(yyf, yyt->U_1.V_16.Ident.Attribute);
  2762.   yyWriteNl();
  2763.   yyWriteSelector((STRING)"Pos", 3L);
  2764.   Positions_WritePosition(yyf, yyt->U_1.V_16.Ident.Pos);
  2765.   yyWriteNl();
  2766.   yyWriteSelector((STRING)"Next", 4L);
  2767.   yyWriteAdr(yyt->U_1.V_16.Ident.Next);
  2768. }
  2769.  
  2770. static void yWriteNodeRemote
  2771. # ifdef __STDC__
  2772. (Tree_tTree yyt)
  2773. # else
  2774. (yyt)
  2775. Tree_tTree yyt;
  2776. # endif
  2777. {
  2778.   yyWriteSelector((STRING)"Designators", 11L);
  2779.   yyWriteAdr(yyt->U_1.V_17.Remote.Designators);
  2780.   yyWriteSelector((STRING)"Type", 4L);
  2781.   Idents_WriteIdent(yyf, yyt->U_1.V_17.Remote.Type);
  2782.   yyWriteNl();
  2783.   yyWriteSelector((STRING)"Attribute", 9L);
  2784.   Idents_WriteIdent(yyf, yyt->U_1.V_17.Remote.Attribute);
  2785.   yyWriteNl();
  2786.   yyWriteSelector((STRING)"Pos", 3L);
  2787.   Positions_WritePosition(yyf, yyt->U_1.V_17.Remote.Pos);
  2788.   yyWriteNl();
  2789.   yyWriteSelector((STRING)"Next", 4L);
  2790.   yyWriteAdr(yyt->U_1.V_17.Remote.Next);
  2791. }
  2792.  
  2793. static void yWriteNodeAny
  2794. # ifdef __STDC__
  2795. (Tree_tTree yyt)
  2796. # else
  2797. (yyt)
  2798. Tree_tTree yyt;
  2799. # endif
  2800. {
  2801.   yyWriteSelector((STRING)"Code", 4L);
  2802.   StringMem_WriteString(yyf, yyt->U_1.V_18.Any.Code);
  2803.   yyWriteNl();
  2804.   yyWriteSelector((STRING)"Next", 4L);
  2805.   yyWriteAdr(yyt->U_1.V_18.Any.Next);
  2806. }
  2807.  
  2808. static void yWriteNodeAnys
  2809. # ifdef __STDC__
  2810. (Tree_tTree yyt)
  2811. # else
  2812. (yyt)
  2813. Tree_tTree yyt;
  2814. # endif
  2815. {
  2816.   yyWriteSelector((STRING)"Layouts", 7L);
  2817.   yyWriteAdr(yyt->U_1.V_19.Anys.Layouts);
  2818.   yyWriteSelector((STRING)"Next", 4L);
  2819.   yyWriteAdr(yyt->U_1.V_19.Anys.Next);
  2820. }
  2821.  
  2822. static void yWriteNodeLayoutAny
  2823. # ifdef __STDC__
  2824. (Tree_tTree yyt)
  2825. # else
  2826. (yyt)
  2827. Tree_tTree yyt;
  2828. # endif
  2829. {
  2830.   yyWriteSelector((STRING)"Code", 4L);
  2831.   StringMem_WriteString(yyf, yyt->U_1.V_22.LayoutAny.Code);
  2832.   yyWriteNl();
  2833.   yyWriteSelector((STRING)"Next", 4L);
  2834.   yyWriteAdr(yyt->U_1.V_22.LayoutAny.Next);
  2835. }
  2836.  
  2837. static void yWriteNodeName
  2838. # ifdef __STDC__
  2839. (Tree_tTree yyt)
  2840. # else
  2841. (yyt)
  2842. Tree_tTree yyt;
  2843. # endif
  2844. {
  2845.   yyWriteSelector((STRING)"Name", 4L);
  2846.   Idents_WriteIdent(yyf, yyt->U_1.V_25.Name.Name);
  2847.   yyWriteNl();
  2848.   yyWriteSelector((STRING)"Pos", 3L);
  2849.   Positions_WritePosition(yyf, yyt->U_1.V_25.Name.Pos);
  2850.   yyWriteNl();
  2851.   yyWriteSelector((STRING)"Next", 4L);
  2852.   yyWriteAdr(yyt->U_1.V_25.Name.Next);
  2853. }
  2854.  
  2855. static void yWriteNodeAg
  2856. # ifdef __STDC__
  2857. (Tree_tTree yyt)
  2858. # else
  2859. (yyt)
  2860. Tree_tTree yyt;
  2861. # endif
  2862. {
  2863.   yyWriteSelector((STRING)"Name", 4L);
  2864.   Idents_WriteIdent(yyf, yyt->U_1.V_26.Ag.Name);
  2865.   yyWriteNl();
  2866.   yyWriteSelector((STRING)"ScannerName", 11L);
  2867.   Idents_WriteIdent(yyf, yyt->U_1.V_26.Ag.ScannerName);
  2868.   yyWriteNl();
  2869.   yyWriteSelector((STRING)"ParserName", 10L);
  2870.   Idents_WriteIdent(yyf, yyt->U_1.V_26.Ag.ParserName);
  2871.   yyWriteNl();
  2872.   yyWriteSelector((STRING)"ParserCodes", 11L);
  2873.   yyWriteAdr(yyt->U_1.V_26.Ag.ParserCodes);
  2874.   yyWriteSelector((STRING)"TreeName", 8L);
  2875.   Idents_WriteIdent(yyf, yyt->U_1.V_26.Ag.TreeName);
  2876.   yyWriteNl();
  2877.   yyWriteSelector((STRING)"TreeCodes", 9L);
  2878.   yyWriteAdr(yyt->U_1.V_26.Ag.TreeCodes);
  2879.   yyWriteSelector((STRING)"EvalName", 8L);
  2880.   Idents_WriteIdent(yyf, yyt->U_1.V_26.Ag.EvalName);
  2881.   yyWriteNl();
  2882.   yyWriteSelector((STRING)"EvalCodes", 9L);
  2883.   yyWriteAdr(yyt->U_1.V_26.Ag.EvalCodes);
  2884.   yyWriteSelector((STRING)"Precs", 5L);
  2885.   yyWriteAdr(yyt->U_1.V_26.Ag.Precs);
  2886.   yyWriteSelector((STRING)"Props", 5L);
  2887.   yyWriteAdr(yyt->U_1.V_26.Ag.Props);
  2888.   yyWriteSelector((STRING)"Decls", 5L);
  2889.   yyWriteAdr(yyt->U_1.V_26.Ag.Decls);
  2890.   yyWriteSelector((STRING)"Classes", 7L);
  2891.   yyWriteAdr(yyt->U_1.V_26.Ag.Classes);
  2892.   yyWriteSelector((STRING)"Modules", 7L);
  2893.   yyWriteAdr(yyt->U_1.V_26.Ag.Modules);
  2894.   yyWriteSelector((STRING)"Properties", 10L);
  2895.   yyWriteHex((WORD *)&yyt->U_1.V_26.Ag.Properties, (LONGCARD)sizeof(yyt->U_1.V_26.Ag.Properties));
  2896.   yyWriteNl();
  2897. }
  2898.  
  2899. static void yWriteNodePrec
  2900. # ifdef __STDC__
  2901. (Tree_tTree yyt)
  2902. # else
  2903. (yyt)
  2904. Tree_tTree yyt;
  2905. # endif
  2906. {
  2907.   yyWriteSelector((STRING)"Names", 5L);
  2908.   yyWriteAdr(yyt->U_1.V_29.Prec.Names);
  2909.   yyWriteSelector((STRING)"Next", 4L);
  2910.   yyWriteAdr(yyt->U_1.V_29.Prec.Next);
  2911. }
  2912.  
  2913. static void yWriteNodeLeftAssoc
  2914. # ifdef __STDC__
  2915. (Tree_tTree yyt)
  2916. # else
  2917. (yyt)
  2918. Tree_tTree yyt;
  2919. # endif
  2920. {
  2921.   yWriteNodePrec(yyt);
  2922. }
  2923.  
  2924. static void yWriteNodeRightAssoc
  2925. # ifdef __STDC__
  2926. (Tree_tTree yyt)
  2927. # else
  2928. (yyt)
  2929. Tree_tTree yyt;
  2930. # endif
  2931. {
  2932.   yWriteNodePrec(yyt);
  2933. }
  2934.  
  2935. static void yWriteNodeNonAssoc
  2936. # ifdef __STDC__
  2937. (Tree_tTree yyt)
  2938. # else
  2939. (yyt)
  2940. Tree_tTree yyt;
  2941. # endif
  2942. {
  2943.   yWriteNodePrec(yyt);
  2944. }
  2945.  
  2946. static void yWriteNodeAction
  2947. # ifdef __STDC__
  2948. (Tree_tTree yyt)
  2949. # else
  2950. (yyt)
  2951. Tree_tTree yyt;
  2952. # endif
  2953. {
  2954.   yyWriteSelector((STRING)"Next", 4L);
  2955.   yyWriteAdr(yyt->U_1.V_35.Action.Next);
  2956.   yyWriteSelector((STRING)"Pos", 3L);
  2957.   Positions_WritePosition(yyf, yyt->U_1.V_35.Action.Pos);
  2958.   yyWriteNl();
  2959. }
  2960.  
  2961. static void yWriteNodeAssign
  2962. # ifdef __STDC__
  2963. (Tree_tTree yyt)
  2964. # else
  2965. (yyt)
  2966. Tree_tTree yyt;
  2967. # endif
  2968. {
  2969.   yWriteNodeAction(yyt);
  2970.   yyWriteSelector((STRING)"Results", 7L);
  2971.   yyWriteAdr(yyt->U_1.V_36.Assign.Results);
  2972.   yyWriteSelector((STRING)"Arguments", 9L);
  2973.   yyWriteAdr(yyt->U_1.V_36.Assign.Arguments);
  2974. }
  2975.  
  2976. static void yWriteNodeCopy
  2977. # ifdef __STDC__
  2978. (Tree_tTree yyt)
  2979. # else
  2980. (yyt)
  2981. Tree_tTree yyt;
  2982. # endif
  2983. {
  2984.   yWriteNodeAction(yyt);
  2985.   yyWriteSelector((STRING)"Results", 7L);
  2986.   yyWriteAdr(yyt->U_1.V_37.Copy.Results);
  2987.   yyWriteSelector((STRING)"Arguments", 9L);
  2988.   yyWriteAdr(yyt->U_1.V_37.Copy.Arguments);
  2989. }
  2990.  
  2991. static void yWriteNodeTargetCode
  2992. # ifdef __STDC__
  2993. (Tree_tTree yyt)
  2994. # else
  2995. (yyt)
  2996. Tree_tTree yyt;
  2997. # endif
  2998. {
  2999.   yWriteNodeAction(yyt);
  3000.   yyWriteSelector((STRING)"Results", 7L);
  3001.   yyWriteAdr(yyt->U_1.V_38.TargetCode.Results);
  3002.   yyWriteSelector((STRING)"Code", 4L);
  3003.   yyWriteAdr(yyt->U_1.V_38.TargetCode.Code);
  3004. }
  3005.  
  3006. static void yWriteNodeOrder
  3007. # ifdef __STDC__
  3008. (Tree_tTree yyt)
  3009. # else
  3010. (yyt)
  3011. Tree_tTree yyt;
  3012. # endif
  3013. {
  3014.   yWriteNodeAction(yyt);
  3015.   yyWriteSelector((STRING)"Results", 7L);
  3016.   yyWriteAdr(yyt->U_1.V_39.Order.Results);
  3017.   yyWriteSelector((STRING)"Arguments", 9L);
  3018.   yyWriteAdr(yyt->U_1.V_39.Order.Arguments);
  3019. }
  3020.  
  3021. static void yWriteNodeCheck
  3022. # ifdef __STDC__
  3023. (Tree_tTree yyt)
  3024. # else
  3025. (yyt)
  3026. Tree_tTree yyt;
  3027. # endif
  3028. {
  3029.   yWriteNodeAction(yyt);
  3030.   yyWriteSelector((STRING)"Condition", 9L);
  3031.   yyWriteAdr(yyt->U_1.V_40.Check.Condition);
  3032.   yyWriteSelector((STRING)"Statement", 9L);
  3033.   yyWriteAdr(yyt->U_1.V_40.Check.Statement);
  3034.   yyWriteSelector((STRING)"Actions", 7L);
  3035.   yyWriteAdr(yyt->U_1.V_40.Check.Actions);
  3036.   yyWriteSelector((STRING)"Results", 7L);
  3037.   yyWriteAdr(yyt->U_1.V_40.Check.Results);
  3038. }
  3039.  
  3040. static void yWriteNodeModule
  3041. # ifdef __STDC__
  3042. (Tree_tTree yyt)
  3043. # else
  3044. (yyt)
  3045. Tree_tTree yyt;
  3046. # endif
  3047. {
  3048.   yyWriteSelector((STRING)"Name", 4L);
  3049.   Idents_WriteIdent(yyf, yyt->U_1.V_43.Module.Name);
  3050.   yyWriteNl();
  3051.   yyWriteSelector((STRING)"ParserCodes", 11L);
  3052.   yyWriteAdr(yyt->U_1.V_43.Module.ParserCodes);
  3053.   yyWriteSelector((STRING)"TreeCodes", 9L);
  3054.   yyWriteAdr(yyt->U_1.V_43.Module.TreeCodes);
  3055.   yyWriteSelector((STRING)"EvalCodes", 9L);
  3056.   yyWriteAdr(yyt->U_1.V_43.Module.EvalCodes);
  3057.   yyWriteSelector((STRING)"Props", 5L);
  3058.   yyWriteAdr(yyt->U_1.V_43.Module.Props);
  3059.   yyWriteSelector((STRING)"Decls", 5L);
  3060.   yyWriteAdr(yyt->U_1.V_43.Module.Decls);
  3061.   yyWriteSelector((STRING)"Classes", 7L);
  3062.   yyWriteAdr(yyt->U_1.V_43.Module.Classes);
  3063.   yyWriteSelector((STRING)"Next", 4L);
  3064.   yyWriteAdr(yyt->U_1.V_43.Module.Next);
  3065.   yyWriteSelector((STRING)"Properties", 10L);
  3066.   yyWriteHex((WORD *)&yyt->U_1.V_43.Module.Properties, (LONGCARD)sizeof(yyt->U_1.V_43.Module.Properties));
  3067.   yyWriteNl();
  3068. }
  3069.  
  3070. static void yWriteNodeProp
  3071. # ifdef __STDC__
  3072. (Tree_tTree yyt)
  3073. # else
  3074. (yyt)
  3075. Tree_tTree yyt;
  3076. # endif
  3077. {
  3078.   yyWriteSelector((STRING)"Properties", 10L);
  3079.   yyWriteHex((WORD *)&yyt->U_1.V_46.Prop.Properties, (LONGCARD)sizeof(yyt->U_1.V_46.Prop.Properties));
  3080.   yyWriteNl();
  3081.   yyWriteSelector((STRING)"Names", 5L);
  3082.   yyWriteAdr(yyt->U_1.V_46.Prop.Names);
  3083.   yyWriteSelector((STRING)"Next", 4L);
  3084.   yyWriteAdr(yyt->U_1.V_46.Prop.Next);
  3085. }
  3086.  
  3087. static void yWriteNodeSelect
  3088. # ifdef __STDC__
  3089. (Tree_tTree yyt)
  3090. # else
  3091. (yyt)
  3092. Tree_tTree yyt;
  3093. # endif
  3094. {
  3095.   yyWriteSelector((STRING)"Names", 5L);
  3096.   yyWriteAdr(yyt->U_1.V_47.Select.Names);
  3097.   yyWriteSelector((STRING)"Next", 4L);
  3098.   yyWriteAdr(yyt->U_1.V_47.Select.Next);
  3099. }
  3100.  
  3101. static void yWriteNodeDecl
  3102. # ifdef __STDC__
  3103. (Tree_tTree yyt)
  3104. # else
  3105. (yyt)
  3106. Tree_tTree yyt;
  3107. # endif
  3108. {
  3109.   yyWriteSelector((STRING)"Names", 5L);
  3110.   yyWriteAdr(yyt->U_1.V_50.Decl.Names);
  3111.   yyWriteSelector((STRING)"Attributes", 10L);
  3112.   yyWriteAdr(yyt->U_1.V_50.Decl.Attributes);
  3113.   yyWriteSelector((STRING)"Properties", 10L);
  3114.   Tree_WriteClassProperties(yyf, yyt->U_1.V_50.Decl.Properties);
  3115.   yyWriteNl();
  3116.   yyWriteSelector((STRING)"Next", 4L);
  3117.   yyWriteAdr(yyt->U_1.V_50.Decl.Next);
  3118. }
  3119.  
  3120. void Tree_WriteTreeNode
  3121. # ifdef __STDC__
  3122. (IO_tFile yyyf, Tree_tTree yyt)
  3123. # else
  3124. (yyyf, yyt)
  3125. IO_tFile yyyf;
  3126. Tree_tTree yyt;
  3127. # endif
  3128. {
  3129.   yyf = yyyf;
  3130.   if (yyt == Tree_NoTree) {
  3131.     IO_WriteS(yyf, (STRING)"NoTree", 6L);
  3132.     yyWriteNl();
  3133.     return;
  3134.   }
  3135.   switch (yyt->U_1.V_1.Kind) {
  3136.   case Tree_Classes:;
  3137.     IO_WriteS(yyf, (STRING)"Classes", 7L);
  3138.     yyWriteNl();
  3139.     break;
  3140.   case Tree_NoClass:;
  3141.     IO_WriteS(yyf, (STRING)"NoClass", 7L);
  3142.     yyWriteNl();
  3143.     break;
  3144.   case Tree_Class:;
  3145.     IO_WriteS(yyf, (STRING)"Class", 5L);
  3146.     yyWriteNl();
  3147.     yWriteNodeClass(yyt);
  3148.     break;
  3149.   case Tree_Attributes:;
  3150.     IO_WriteS(yyf, (STRING)"Attributes", 10L);
  3151.     yyWriteNl();
  3152.     break;
  3153.   case Tree_NoAttribute:;
  3154.     IO_WriteS(yyf, (STRING)"NoAttribute", 11L);
  3155.     yyWriteNl();
  3156.     break;
  3157.   case Tree_AttrOrAction:;
  3158.     IO_WriteS(yyf, (STRING)"AttrOrAction", 12L);
  3159.     yyWriteNl();
  3160.     yWriteNodeAttrOrAction(yyt);
  3161.     break;
  3162.   case Tree_Child:;
  3163.     IO_WriteS(yyf, (STRING)"Child", 5L);
  3164.     yyWriteNl();
  3165.     yWriteNodeChild(yyt);
  3166.     break;
  3167.   case Tree_Attribute:;
  3168.     IO_WriteS(yyf, (STRING)"Attribute", 9L);
  3169.     yyWriteNl();
  3170.     yWriteNodeAttribute(yyt);
  3171.     break;
  3172.   case Tree_ActionPart:;
  3173.     IO_WriteS(yyf, (STRING)"ActionPart", 10L);
  3174.     yyWriteNl();
  3175.     yWriteNodeActionPart(yyt);
  3176.     break;
  3177.   case Tree_Codes:;
  3178.     IO_WriteS(yyf, (STRING)"Codes", 5L);
  3179.     yyWriteNl();
  3180.     yWriteNodeCodes(yyt);
  3181.     break;
  3182.   case Tree_Designators:;
  3183.     IO_WriteS(yyf, (STRING)"Designators", 11L);
  3184.     yyWriteNl();
  3185.     break;
  3186.   case Tree_NoDesignator:;
  3187.     IO_WriteS(yyf, (STRING)"NoDesignator", 12L);
  3188.     yyWriteNl();
  3189.     break;
  3190.   case Tree_Designator:;
  3191.     IO_WriteS(yyf, (STRING)"Designator", 10L);
  3192.     yyWriteNl();
  3193.     yWriteNodeDesignator(yyt);
  3194.     break;
  3195.   case Tree_Ident:;
  3196.     IO_WriteS(yyf, (STRING)"Ident", 5L);
  3197.     yyWriteNl();
  3198.     yWriteNodeIdent(yyt);
  3199.     break;
  3200.   case Tree_Remote:;
  3201.     IO_WriteS(yyf, (STRING)"Remote", 6L);
  3202.     yyWriteNl();
  3203.     yWriteNodeRemote(yyt);
  3204.     break;
  3205.   case Tree_Any:;
  3206.     IO_WriteS(yyf, (STRING)"Any", 3L);
  3207.     yyWriteNl();
  3208.     yWriteNodeAny(yyt);
  3209.     break;
  3210.   case Tree_Anys:;
  3211.     IO_WriteS(yyf, (STRING)"Anys", 4L);
  3212.     yyWriteNl();
  3213.     yWriteNodeAnys(yyt);
  3214.     break;
  3215.   case Tree_Layouts:;
  3216.     IO_WriteS(yyf, (STRING)"Layouts", 7L);
  3217.     yyWriteNl();
  3218.     break;
  3219.   case Tree_NoLayout:;
  3220.     IO_WriteS(yyf, (STRING)"NoLayout", 8L);
  3221.     yyWriteNl();
  3222.     break;
  3223.   case Tree_LayoutAny:;
  3224.     IO_WriteS(yyf, (STRING)"LayoutAny", 9L);
  3225.     yyWriteNl();
  3226.     yWriteNodeLayoutAny(yyt);
  3227.     break;
  3228.   case Tree_Names:;
  3229.     IO_WriteS(yyf, (STRING)"Names", 5L);
  3230.     yyWriteNl();
  3231.     break;
  3232.   case Tree_NoName:;
  3233.     IO_WriteS(yyf, (STRING)"NoName", 6L);
  3234.     yyWriteNl();
  3235.     break;
  3236.   case Tree_Name:;
  3237.     IO_WriteS(yyf, (STRING)"Name", 4L);
  3238.     yyWriteNl();
  3239.     yWriteNodeName(yyt);
  3240.     break;
  3241.   case Tree_Ag:;
  3242.     IO_WriteS(yyf, (STRING)"Ag", 2L);
  3243.     yyWriteNl();
  3244.     yWriteNodeAg(yyt);
  3245.     break;
  3246.   case Tree_Precs:;
  3247.     IO_WriteS(yyf, (STRING)"Precs", 5L);
  3248.     yyWriteNl();
  3249.     break;
  3250.   case Tree_NoPrec:;
  3251.     IO_WriteS(yyf, (STRING)"NoPrec", 6L);
  3252.     yyWriteNl();
  3253.     break;
  3254.   case Tree_Prec:;
  3255.     IO_WriteS(yyf, (STRING)"Prec", 4L);
  3256.     yyWriteNl();
  3257.     yWriteNodePrec(yyt);
  3258.     break;
  3259.   case Tree_LeftAssoc:;
  3260.     IO_WriteS(yyf, (STRING)"LeftAssoc", 9L);
  3261.     yyWriteNl();
  3262.     yWriteNodeLeftAssoc(yyt);
  3263.     break;
  3264.   case Tree_RightAssoc:;
  3265.     IO_WriteS(yyf, (STRING)"RightAssoc", 10L);
  3266.     yyWriteNl();
  3267.     yWriteNodeRightAssoc(yyt);
  3268.     break;
  3269.   case Tree_NonAssoc:;
  3270.     IO_WriteS(yyf, (STRING)"NonAssoc", 8L);
  3271.     yyWriteNl();
  3272.     yWriteNodeNonAssoc(yyt);
  3273.     break;
  3274.   case Tree_Actions:;
  3275.     IO_WriteS(yyf, (STRING)"Actions", 7L);
  3276.     yyWriteNl();
  3277.     break;
  3278.   case Tree_NoAction:;
  3279.     IO_WriteS(yyf, (STRING)"NoAction", 8L);
  3280.     yyWriteNl();
  3281.     break;
  3282.   case Tree_Action:;
  3283.     IO_WriteS(yyf, (STRING)"Action", 6L);
  3284.     yyWriteNl();
  3285.     yWriteNodeAction(yyt);
  3286.     break;
  3287.   case Tree_Assign:;
  3288.     IO_WriteS(yyf, (STRING)"Assign", 6L);
  3289.     yyWriteNl();
  3290.     yWriteNodeAssign(yyt);
  3291.     break;
  3292.   case Tree_Copy:;
  3293.     IO_WriteS(yyf, (STRING)"Copy", 4L);
  3294.     yyWriteNl();
  3295.     yWriteNodeCopy(yyt);
  3296.     break;
  3297.   case Tree_TargetCode:;
  3298.     IO_WriteS(yyf, (STRING)"TargetCode", 10L);
  3299.     yyWriteNl();
  3300.     yWriteNodeTargetCode(yyt);
  3301.     break;
  3302.   case Tree_Order:;
  3303.     IO_WriteS(yyf, (STRING)"Order", 5L);
  3304.     yyWriteNl();
  3305.     yWriteNodeOrder(yyt);
  3306.     break;
  3307.   case Tree_Check:;
  3308.     IO_WriteS(yyf, (STRING)"Check", 5L);
  3309.     yyWriteNl();
  3310.     yWriteNodeCheck(yyt);
  3311.     break;
  3312.   case Tree_Modules:;
  3313.     IO_WriteS(yyf, (STRING)"Modules", 7L);
  3314.     yyWriteNl();
  3315.     break;
  3316.   case Tree_NoModule:;
  3317.     IO_WriteS(yyf, (STRING)"NoModule", 8L);
  3318.     yyWriteNl();
  3319.     break;
  3320.   case Tree_Module:;
  3321.     IO_WriteS(yyf, (STRING)"Module", 6L);
  3322.     yyWriteNl();
  3323.     yWriteNodeModule(yyt);
  3324.     break;
  3325.   case Tree_Props:;
  3326.     IO_WriteS(yyf, (STRING)"Props", 5L);
  3327.     yyWriteNl();
  3328.     break;
  3329.   case Tree_NoProp:;
  3330.     IO_WriteS(yyf, (STRING)"NoProp", 6L);
  3331.     yyWriteNl();
  3332.     break;
  3333.   case Tree_Prop:;
  3334.     IO_WriteS(yyf, (STRING)"Prop", 4L);
  3335.     yyWriteNl();
  3336.     yWriteNodeProp(yyt);
  3337.     break;
  3338.   case Tree_Select:;
  3339.     IO_WriteS(yyf, (STRING)"Select", 6L);
  3340.     yyWriteNl();
  3341.     yWriteNodeSelect(yyt);
  3342.     break;
  3343.   case Tree_Decls:;
  3344.     IO_WriteS(yyf, (STRING)"Decls", 5L);
  3345.     yyWriteNl();
  3346.     break;
  3347.   case Tree_NoDecl:;
  3348.     IO_WriteS(yyf, (STRING)"NoDecl", 6L);
  3349.     yyWriteNl();
  3350.     break;
  3351.   case Tree_Decl:;
  3352.     IO_WriteS(yyf, (STRING)"Decl", 4L);
  3353.     yyWriteNl();
  3354.     yWriteNodeDecl(yyt);
  3355.     break;
  3356.   default :
  3357.     break;
  3358.   }
  3359. }
  3360.  
  3361. Tree_tTree Tree_ReverseTree
  3362. # ifdef __STDC__
  3363. (Tree_tTree yyOld)
  3364. # else
  3365. (yyOld)
  3366. Tree_tTree yyOld;
  3367. # endif
  3368. {
  3369.   Tree_tTree yyNew, yyNext, yyTail;
  3370.  
  3371.   yyNew = yyOld;
  3372.   yyTail = yyOld;
  3373.   for (;;) {
  3374.     switch (yyOld->U_1.V_1.Kind) {
  3375.     case Tree_Class:;
  3376.       yyNext = yyOld->U_1.V_5.Class.Next;
  3377.       yyOld->U_1.V_5.Class.Next = yyNew;
  3378.       break;
  3379.     case Tree_AttrOrAction:;
  3380.       yyNext = yyOld->U_1.V_8.AttrOrAction.Next;
  3381.       yyOld->U_1.V_8.AttrOrAction.Next = yyNew;
  3382.       break;
  3383.     case Tree_Child:;
  3384.       yyNext = yyOld->U_1.V_9.Child.Next;
  3385.       yyOld->U_1.V_9.Child.Next = yyNew;
  3386.       break;
  3387.     case Tree_Attribute:;
  3388.       yyNext = yyOld->U_1.V_10.Attribute.Next;
  3389.       yyOld->U_1.V_10.Attribute.Next = yyNew;
  3390.       break;
  3391.     case Tree_ActionPart:;
  3392.       yyNext = yyOld->U_1.V_11.ActionPart.Next;
  3393.       yyOld->U_1.V_11.ActionPart.Next = yyNew;
  3394.       break;
  3395.     case Tree_Designator:;
  3396.       yyNext = yyOld->U_1.V_15.Designator.Next;
  3397.       yyOld->U_1.V_15.Designator.Next = yyNew;
  3398.       break;
  3399.     case Tree_Ident:;
  3400.       yyNext = yyOld->U_1.V_16.Ident.Next;
  3401.       yyOld->U_1.V_16.Ident.Next = yyNew;
  3402.       break;
  3403.     case Tree_Remote:;
  3404.       yyNext = yyOld->U_1.V_17.Remote.Next;
  3405.       yyOld->U_1.V_17.Remote.Next = yyNew;
  3406.       break;
  3407.     case Tree_Any:;
  3408.       yyNext = yyOld->U_1.V_18.Any.Next;
  3409.       yyOld->U_1.V_18.Any.Next = yyNew;
  3410.       break;
  3411.     case Tree_Anys:;
  3412.       yyNext = yyOld->U_1.V_19.Anys.Next;
  3413.       yyOld->U_1.V_19.Anys.Next = yyNew;
  3414.       break;
  3415.     case Tree_LayoutAny:;
  3416.       yyNext = yyOld->U_1.V_22.LayoutAny.Next;
  3417.       yyOld->U_1.V_22.LayoutAny.Next = yyNew;
  3418.       break;
  3419.     case Tree_Name:;
  3420.       yyNext = yyOld->U_1.V_25.Name.Next;
  3421.       yyOld->U_1.V_25.Name.Next = yyNew;
  3422.       break;
  3423.     case Tree_Prec:;
  3424.       yyNext = yyOld->U_1.V_29.Prec.Next;
  3425.       yyOld->U_1.V_29.Prec.Next = yyNew;
  3426.       break;
  3427.     case Tree_LeftAssoc:;
  3428.       yyNext = yyOld->U_1.V_30.LeftAssoc.Next;
  3429.       yyOld->U_1.V_30.LeftAssoc.Next = yyNew;
  3430.       break;
  3431.     case Tree_RightAssoc:;
  3432.       yyNext = yyOld->U_1.V_31.RightAssoc.Next;
  3433.       yyOld->U_1.V_31.RightAssoc.Next = yyNew;
  3434.       break;
  3435.     case Tree_NonAssoc:;
  3436.       yyNext = yyOld->U_1.V_32.NonAssoc.Next;
  3437.       yyOld->U_1.V_32.NonAssoc.Next = yyNew;
  3438.       break;
  3439.     case Tree_Action:;
  3440.       yyNext = yyOld->U_1.V_35.Action.Next;
  3441.       yyOld->U_1.V_35.Action.Next = yyNew;
  3442.       break;
  3443.     case Tree_Assign:;
  3444.       yyNext = yyOld->U_1.V_36.Assign.Next;
  3445.       yyOld->U_1.V_36.Assign.Next = yyNew;
  3446.       break;
  3447.     case Tree_Copy:;
  3448.       yyNext = yyOld->U_1.V_37.Copy.Next;
  3449.       yyOld->U_1.V_37.Copy.Next = yyNew;
  3450.       break;
  3451.     case Tree_TargetCode:;
  3452.       yyNext = yyOld->U_1.V_38.TargetCode.Next;
  3453.       yyOld->U_1.V_38.TargetCode.Next = yyNew;
  3454.       break;
  3455.     case Tree_Order:;
  3456.       yyNext = yyOld->U_1.V_39.Order.Next;
  3457.       yyOld->U_1.V_39.Order.Next = yyNew;
  3458.       break;
  3459.     case Tree_Check:;
  3460.       yyNext = yyOld->U_1.V_40.Check.Next;
  3461.       yyOld->U_1.V_40.Check.Next = yyNew;
  3462.       break;
  3463.     case Tree_Module:;
  3464.       yyNext = yyOld->U_1.V_43.Module.Next;
  3465.       yyOld->U_1.V_43.Module.Next = yyNew;
  3466.       break;
  3467.     case Tree_Prop:;
  3468.       yyNext = yyOld->U_1.V_46.Prop.Next;
  3469.       yyOld->U_1.V_46.Prop.Next = yyNew;
  3470.       break;
  3471.     case Tree_Select:;
  3472.       yyNext = yyOld->U_1.V_47.Select.Next;
  3473.       yyOld->U_1.V_47.Select.Next = yyNew;
  3474.       break;
  3475.     case Tree_Decl:;
  3476.       yyNext = yyOld->U_1.V_50.Decl.Next;
  3477.       yyOld->U_1.V_50.Decl.Next = yyNew;
  3478.       break;
  3479.     default :
  3480.       goto EXIT_3;
  3481.       break;
  3482.     }
  3483.     yyNew = yyOld;
  3484.     yyOld = yyNext;
  3485.   } EXIT_3:;
  3486.   switch (yyTail->U_1.V_1.Kind) {
  3487.   case Tree_Class:;
  3488.     yyTail->U_1.V_5.Class.Next = yyOld;
  3489.     break;
  3490.   case Tree_AttrOrAction:;
  3491.     yyTail->U_1.V_8.AttrOrAction.Next = yyOld;
  3492.     break;
  3493.   case Tree_Child:;
  3494.     yyTail->U_1.V_9.Child.Next = yyOld;
  3495.     break;
  3496.   case Tree_Attribute:;
  3497.     yyTail->U_1.V_10.Attribute.Next = yyOld;
  3498.     break;
  3499.   case Tree_ActionPart:;
  3500.     yyTail->U_1.V_11.ActionPart.Next = yyOld;
  3501.     break;
  3502.   case Tree_Designator:;
  3503.     yyTail->U_1.V_15.Designator.Next = yyOld;
  3504.     break;
  3505.   case Tree_Ident:;
  3506.     yyTail->U_1.V_16.Ident.Next = yyOld;
  3507.     break;
  3508.   case Tree_Remote:;
  3509.     yyTail->U_1.V_17.Remote.Next = yyOld;
  3510.     break;
  3511.   case Tree_Any:;
  3512.     yyTail->U_1.V_18.Any.Next = yyOld;
  3513.     break;
  3514.   case Tree_Anys:;
  3515.     yyTail->U_1.V_19.Anys.Next = yyOld;
  3516.     break;
  3517.   case Tree_LayoutAny:;
  3518.     yyTail->U_1.V_22.LayoutAny.Next = yyOld;
  3519.     break;
  3520.   case Tree_Name:;
  3521.     yyTail->U_1.V_25.Name.Next = yyOld;
  3522.     break;
  3523.   case Tree_Prec:;
  3524.     yyTail->U_1.V_29.Prec.Next = yyOld;
  3525.     break;
  3526.   case Tree_LeftAssoc:;
  3527.     yyTail->U_1.V_30.LeftAssoc.Next = yyOld;
  3528.     break;
  3529.   case Tree_RightAssoc:;
  3530.     yyTail->U_1.V_31.RightAssoc.Next = yyOld;
  3531.     break;
  3532.   case Tree_NonAssoc:;
  3533.     yyTail->U_1.V_32.NonAssoc.Next = yyOld;
  3534.     break;
  3535.   case Tree_Action:;
  3536.     yyTail->U_1.V_35.Action.Next = yyOld;
  3537.     break;
  3538.   case Tree_Assign:;
  3539.     yyTail->U_1.V_36.Assign.Next = yyOld;
  3540.     break;
  3541.   case Tree_Copy:;
  3542.     yyTail->U_1.V_37.Copy.Next = yyOld;
  3543.     break;
  3544.   case Tree_TargetCode:;
  3545.     yyTail->U_1.V_38.TargetCode.Next = yyOld;
  3546.     break;
  3547.   case Tree_Order:;
  3548.     yyTail->U_1.V_39.Order.Next = yyOld;
  3549.     break;
  3550.   case Tree_Check:;
  3551.     yyTail->U_1.V_40.Check.Next = yyOld;
  3552.     break;
  3553.   case Tree_Module:;
  3554.     yyTail->U_1.V_43.Module.Next = yyOld;
  3555.     break;
  3556.   case Tree_Prop:;
  3557.     yyTail->U_1.V_46.Prop.Next = yyOld;
  3558.     break;
  3559.   case Tree_Select:;
  3560.     yyTail->U_1.V_47.Select.Next = yyOld;
  3561.     break;
  3562.   case Tree_Decl:;
  3563.     yyTail->U_1.V_50.Decl.Next = yyOld;
  3564.     break;
  3565.   default :
  3566.     break;
  3567.   }
  3568.   return yyNew;
  3569. }
  3570.  
  3571. static BOOLEAN yyyIsEqual
  3572. # ifdef __STDC__
  3573. (CHAR yya[], LONGCARD O_3)
  3574. # else
  3575. (yya, O_3)
  3576. CHAR yya[];
  3577. LONGCARD O_3;
  3578. # endif
  3579. {
  3580.   INTEGER yyi;
  3581.   OPEN_ARRAY_LOCALS
  3582.  
  3583.   ALLOC_OPEN_ARRAYS(O_3 * sizeof(CHAR), 1)
  3584.   COPY_OPEN_ARRAY(yya, O_3, CHAR)
  3585.   if (yyLength >= 0 && yyString.A[yyLength] == ' ') {
  3586.     if (yyLength - 1 != (INTEGER)(O_3 - 1)) {
  3587.       FREE_OPEN_ARRAYS
  3588.       return FALSE;
  3589.     }
  3590.     {
  3591.       LONGINT B_15 = 0, B_16 = yyLength - 1;
  3592.  
  3593.       if (B_15 <= B_16)
  3594.         for (yyi = B_15;; yyi += 1) {
  3595.           if (yyString.A[yyi] != yya[yyi]) {
  3596.             FREE_OPEN_ARRAYS
  3597.             return FALSE;
  3598.           }
  3599.           if (yyi >= B_16) break;
  3600.         }
  3601.     }
  3602.   } else {
  3603.     if (yyLength > (INTEGER)(O_3 - 1)) {
  3604.       FREE_OPEN_ARRAYS
  3605.       return FALSE;
  3606.     }
  3607.     {
  3608.       LONGINT B_17 = 0, B_18 = yyLength;
  3609.  
  3610.       if (B_17 <= B_18)
  3611.         for (yyi = B_17;; yyi += 1) {
  3612.           if (yyString.A[yyi] != yya[yyi]) {
  3613.             FREE_OPEN_ARRAYS
  3614.             return FALSE;
  3615.           }
  3616.           if (yyi >= B_18) break;
  3617.         }
  3618.     }
  3619.   }
  3620.   FREE_OPEN_ARRAYS
  3621.   return TRUE;
  3622. }
  3623.  
  3624. void Tree_QueryTree
  3625. # ifdef __STDC__
  3626. (Tree_tTree yyt)
  3627. # else
  3628. (yyt)
  3629. Tree_tTree yyt;
  3630. # endif
  3631. {
  3632.   yyState = yyyWrite;
  3633.   for (;;) {
  3634.     switch (yyState) {
  3635.     case yyyQuit:;
  3636.       return;
  3637.       break;
  3638.     case yyyWrite:;
  3639.       Tree_WriteTreeNode((System_tFile)IO_StdOutput, yyt);
  3640.       yyState = yyyRead;
  3641.       break;
  3642.     case yyyRead:;
  3643.       IO_WriteS((System_tFile)IO_StdOutput, (STRING)"? ", 2L);
  3644.       yyLength = -1;
  3645.       yyCh = IO_ReadC((System_tFile)IO_StdInput);
  3646.       while (yyCh != '\n') {
  3647.         INC(yyLength);
  3648.         yyString.A[yyLength] = yyCh;
  3649.         yyCh = IO_ReadC((System_tFile)IO_StdInput);
  3650.       }
  3651.       if (yyyIsEqual((STRING)"parent", 6L)) {
  3652.         yyState = yyyWrite;
  3653.         return;
  3654.       } else if (yyyIsEqual((STRING)"quit", 4L)) {
  3655.         yyState = yyyQuit;
  3656.         return;
  3657.       } else if (yyt != Tree_NoTree) {
  3658.         switch (yyt->U_1.V_1.Kind) {
  3659.         case Tree_Class:;
  3660.           if (FALSE) {
  3661.           } else if (yyyIsEqual((STRING)"Attributes", 10L)) {
  3662.             Tree_QueryTree(yyt->U_1.V_5.Class.Attributes);
  3663.           } else if (yyyIsEqual((STRING)"Extensions", 10L)) {
  3664.             Tree_QueryTree(yyt->U_1.V_5.Class.Extensions);
  3665.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  3666.             Tree_QueryTree(yyt->U_1.V_5.Class.Next);
  3667.           } else if (yyyIsEqual((STRING)"BaseClass", 9L)) {
  3668.             Tree_QueryTree(yyt->U_1.V_5.Class.BaseClass);
  3669.           } else if (yyyIsEqual((STRING)"Names", 5L)) {
  3670.             Tree_QueryTree(yyt->U_1.V_5.Class.Names);
  3671.           }
  3672.           break;
  3673.         case Tree_AttrOrAction:;
  3674.           if (FALSE) {
  3675.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  3676.             Tree_QueryTree(yyt->U_1.V_8.AttrOrAction.Next);
  3677.           }
  3678.           break;
  3679.         case Tree_Child:;
  3680.           if (FALSE) {
  3681.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  3682.             Tree_QueryTree(yyt->U_1.V_9.Child.Next);
  3683.           }
  3684.           break;
  3685.         case Tree_Attribute:;
  3686.           if (FALSE) {
  3687.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  3688.             Tree_QueryTree(yyt->U_1.V_10.Attribute.Next);
  3689.           }
  3690.           break;
  3691.         case Tree_ActionPart:;
  3692.           if (FALSE) {
  3693.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  3694.             Tree_QueryTree(yyt->U_1.V_11.ActionPart.Next);
  3695.           } else if (yyyIsEqual((STRING)"Actions", 7L)) {
  3696.             Tree_QueryTree(yyt->U_1.V_11.ActionPart.Actions);
  3697.           }
  3698.           break;
  3699.         case Tree_Designator:;
  3700.           if (FALSE) {
  3701.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  3702.             Tree_QueryTree(yyt->U_1.V_15.Designator.Next);
  3703.           }
  3704.           break;
  3705.         case Tree_Ident:;
  3706.           if (FALSE) {
  3707.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  3708.             Tree_QueryTree(yyt->U_1.V_16.Ident.Next);
  3709.           }
  3710.           break;
  3711.         case Tree_Remote:;
  3712.           if (FALSE) {
  3713.           } else if (yyyIsEqual((STRING)"Designators", 11L)) {
  3714.             Tree_QueryTree(yyt->U_1.V_17.Remote.Designators);
  3715.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  3716.             Tree_QueryTree(yyt->U_1.V_17.Remote.Next);
  3717.           }
  3718.           break;
  3719.         case Tree_Any:;
  3720.           if (FALSE) {
  3721.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  3722.             Tree_QueryTree(yyt->U_1.V_18.Any.Next);
  3723.           }
  3724.           break;
  3725.         case Tree_Anys:;
  3726.           if (FALSE) {
  3727.           } else if (yyyIsEqual((STRING)"Layouts", 7L)) {
  3728.             Tree_QueryTree(yyt->U_1.V_19.Anys.Layouts);
  3729.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  3730.             Tree_QueryTree(yyt->U_1.V_19.Anys.Next);
  3731.           }
  3732.           break;
  3733.         case Tree_LayoutAny:;
  3734.           if (FALSE) {
  3735.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  3736.             Tree_QueryTree(yyt->U_1.V_22.LayoutAny.Next);
  3737.           }
  3738.           break;
  3739.         case Tree_Name:;
  3740.           if (FALSE) {
  3741.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  3742.             Tree_QueryTree(yyt->U_1.V_25.Name.Next);
  3743.           }
  3744.           break;
  3745.         case Tree_Ag:;
  3746.           if (FALSE) {
  3747.           } else if (yyyIsEqual((STRING)"ParserCodes", 11L)) {
  3748.             Tree_QueryTree(yyt->U_1.V_26.Ag.ParserCodes);
  3749.           } else if (yyyIsEqual((STRING)"TreeCodes", 9L)) {
  3750.             Tree_QueryTree(yyt->U_1.V_26.Ag.TreeCodes);
  3751.           } else if (yyyIsEqual((STRING)"EvalCodes", 9L)) {
  3752.             Tree_QueryTree(yyt->U_1.V_26.Ag.EvalCodes);
  3753.           } else if (yyyIsEqual((STRING)"Precs", 5L)) {
  3754.             Tree_QueryTree(yyt->U_1.V_26.Ag.Precs);
  3755.           } else if (yyyIsEqual((STRING)"Props", 5L)) {
  3756.             Tree_QueryTree(yyt->U_1.V_26.Ag.Props);
  3757.           } else if (yyyIsEqual((STRING)"Decls", 5L)) {
  3758.             Tree_QueryTree(yyt->U_1.V_26.Ag.Decls);
  3759.           } else if (yyyIsEqual((STRING)"Classes", 7L)) {
  3760.             Tree_QueryTree(yyt->U_1.V_26.Ag.Classes);
  3761.           } else if (yyyIsEqual((STRING)"Modules", 7L)) {
  3762.             Tree_QueryTree(yyt->U_1.V_26.Ag.Modules);
  3763.           }
  3764.           break;
  3765.         case Tree_Prec:;
  3766.           if (FALSE) {
  3767.           } else if (yyyIsEqual((STRING)"Names", 5L)) {
  3768.             Tree_QueryTree(yyt->U_1.V_29.Prec.Names);
  3769.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  3770.             Tree_QueryTree(yyt->U_1.V_29.Prec.Next);
  3771.           }
  3772.           break;
  3773.         case Tree_LeftAssoc:;
  3774.           if (FALSE) {
  3775.           } else if (yyyIsEqual((STRING)"Names", 5L)) {
  3776.             Tree_QueryTree(yyt->U_1.V_30.LeftAssoc.Names);
  3777.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  3778.             Tree_QueryTree(yyt->U_1.V_30.LeftAssoc.Next);
  3779.           }
  3780.           break;
  3781.         case Tree_RightAssoc:;
  3782.           if (FALSE) {
  3783.           } else if (yyyIsEqual((STRING)"Names", 5L)) {
  3784.             Tree_QueryTree(yyt->U_1.V_31.RightAssoc.Names);
  3785.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  3786.             Tree_QueryTree(yyt->U_1.V_31.RightAssoc.Next);
  3787.           }
  3788.           break;
  3789.         case Tree_NonAssoc:;
  3790.           if (FALSE) {
  3791.           } else if (yyyIsEqual((STRING)"Names", 5L)) {
  3792.             Tree_QueryTree(yyt->U_1.V_32.NonAssoc.Names);
  3793.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  3794.             Tree_QueryTree(yyt->U_1.V_32.NonAssoc.Next);
  3795.           }
  3796.           break;
  3797.         case Tree_Action:;
  3798.           if (FALSE) {
  3799.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  3800.             Tree_QueryTree(yyt->U_1.V_35.Action.Next);
  3801.           }
  3802.           break;
  3803.         case Tree_Assign:;
  3804.           if (FALSE) {
  3805.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  3806.             Tree_QueryTree(yyt->U_1.V_36.Assign.Next);
  3807.           } else if (yyyIsEqual((STRING)"Results", 7L)) {
  3808.             Tree_QueryTree(yyt->U_1.V_36.Assign.Results);
  3809.           } else if (yyyIsEqual((STRING)"Arguments", 9L)) {
  3810.             Tree_QueryTree(yyt->U_1.V_36.Assign.Arguments);
  3811.           }
  3812.           break;
  3813.         case Tree_Copy:;
  3814.           if (FALSE) {
  3815.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  3816.             Tree_QueryTree(yyt->U_1.V_37.Copy.Next);
  3817.           } else if (yyyIsEqual((STRING)"Results", 7L)) {
  3818.             Tree_QueryTree(yyt->U_1.V_37.Copy.Results);
  3819.           } else if (yyyIsEqual((STRING)"Arguments", 9L)) {
  3820.             Tree_QueryTree(yyt->U_1.V_37.Copy.Arguments);
  3821.           }
  3822.           break;
  3823.         case Tree_TargetCode:;
  3824.           if (FALSE) {
  3825.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  3826.             Tree_QueryTree(yyt->U_1.V_38.TargetCode.Next);
  3827.           } else if (yyyIsEqual((STRING)"Results", 7L)) {
  3828.             Tree_QueryTree(yyt->U_1.V_38.TargetCode.Results);
  3829.           } else if (yyyIsEqual((STRING)"Code", 4L)) {
  3830.             Tree_QueryTree(yyt->U_1.V_38.TargetCode.Code);
  3831.           }
  3832.           break;
  3833.         case Tree_Order:;
  3834.           if (FALSE) {
  3835.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  3836.             Tree_QueryTree(yyt->U_1.V_39.Order.Next);
  3837.           } else if (yyyIsEqual((STRING)"Results", 7L)) {
  3838.             Tree_QueryTree(yyt->U_1.V_39.Order.Results);
  3839.           } else if (yyyIsEqual((STRING)"Arguments", 9L)) {
  3840.             Tree_QueryTree(yyt->U_1.V_39.Order.Arguments);
  3841.           }
  3842.           break;
  3843.         case Tree_Check:;
  3844.           if (FALSE) {
  3845.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  3846.             Tree_QueryTree(yyt->U_1.V_40.Check.Next);
  3847.           } else if (yyyIsEqual((STRING)"Condition", 9L)) {
  3848.             Tree_QueryTree(yyt->U_1.V_40.Check.Condition);
  3849.           } else if (yyyIsEqual((STRING)"Statement", 9L)) {
  3850.             Tree_QueryTree(yyt->U_1.V_40.Check.Statement);
  3851.           } else if (yyyIsEqual((STRING)"Actions", 7L)) {
  3852.             Tree_QueryTree(yyt->U_1.V_40.Check.Actions);
  3853.           } else if (yyyIsEqual((STRING)"Results", 7L)) {
  3854.             Tree_QueryTree(yyt->U_1.V_40.Check.Results);
  3855.           }
  3856.           break;
  3857.         case Tree_Module:;
  3858.           if (FALSE) {
  3859.           } else if (yyyIsEqual((STRING)"ParserCodes", 11L)) {
  3860.             Tree_QueryTree(yyt->U_1.V_43.Module.ParserCodes);
  3861.           } else if (yyyIsEqual((STRING)"TreeCodes", 9L)) {
  3862.             Tree_QueryTree(yyt->U_1.V_43.Module.TreeCodes);
  3863.           } else if (yyyIsEqual((STRING)"EvalCodes", 9L)) {
  3864.             Tree_QueryTree(yyt->U_1.V_43.Module.EvalCodes);
  3865.           } else if (yyyIsEqual((STRING)"Props", 5L)) {
  3866.             Tree_QueryTree(yyt->U_1.V_43.Module.Props);
  3867.           } else if (yyyIsEqual((STRING)"Decls", 5L)) {
  3868.             Tree_QueryTree(yyt->U_1.V_43.Module.Decls);
  3869.           } else if (yyyIsEqual((STRING)"Classes", 7L)) {
  3870.             Tree_QueryTree(yyt->U_1.V_43.Module.Classes);
  3871.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  3872.             Tree_QueryTree(yyt->U_1.V_43.Module.Next);
  3873.           }
  3874.           break;
  3875.         case Tree_Prop:;
  3876.           if (FALSE) {
  3877.           } else if (yyyIsEqual((STRING)"Names", 5L)) {
  3878.             Tree_QueryTree(yyt->U_1.V_46.Prop.Names);
  3879.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  3880.             Tree_QueryTree(yyt->U_1.V_46.Prop.Next);
  3881.           }
  3882.           break;
  3883.         case Tree_Select:;
  3884.           if (FALSE) {
  3885.           } else if (yyyIsEqual((STRING)"Names", 5L)) {
  3886.             Tree_QueryTree(yyt->U_1.V_47.Select.Names);
  3887.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  3888.             Tree_QueryTree(yyt->U_1.V_47.Select.Next);
  3889.           }
  3890.           break;
  3891.         case Tree_Decl:;
  3892.           if (FALSE) {
  3893.           } else if (yyyIsEqual((STRING)"Names", 5L)) {
  3894.             Tree_QueryTree(yyt->U_1.V_50.Decl.Names);
  3895.           } else if (yyyIsEqual((STRING)"Attributes", 10L)) {
  3896.             Tree_QueryTree(yyt->U_1.V_50.Decl.Attributes);
  3897.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  3898.             Tree_QueryTree(yyt->U_1.V_50.Decl.Next);
  3899.           }
  3900.           break;
  3901.         default :
  3902.           break;
  3903.         }
  3904.       }
  3905.       break;
  3906.     }
  3907.   } EXIT_4:;
  3908. }
  3909.  
  3910. void Tree_BeginTree
  3911. # ifdef __STDC__
  3912. ()
  3913. # else
  3914. ()
  3915. # endif
  3916. {
  3917.   Tree_ErrorCount = 0;
  3918.   Sets_MakeSet(&Tree_Options, 127L);
  3919.   Tree_NoCodeAttr = SET_ELEM(Tree_Test) | SET_ELEM(Tree_Dummy) | SET_ELEM(Tree_Virtual) | SET_ELEM(Tree_Parameter);
  3920.   Tree_NoCodeClass = SET_ELEM(Tree_Ignore) | SET_ELEM(Tree_Abstract);
  3921.   Sets_MakeSet(&DummySet, 0L);
  3922.   Relations_MakeRelation(&DummyRelation, 0L, 0L);
  3923.   Tree_nNoAction = Tree_mNoAction();
  3924.   Tree_nNoAttribute = Tree_mNoAttribute();
  3925.   Tree_nNoClass = Tree_mNoClass();
  3926.   Tree_nNoDecl = Tree_mNoDecl();
  3927.   Tree_nNoDesignator = Tree_mNoDesignator();
  3928.   Tree_nNoLayout = Tree_mNoLayout();
  3929.   Tree_nNoModule = Tree_mNoModule();
  3930.   Tree_nNoName = Tree_mNoName();
  3931.   Tree_nNoPrec = Tree_mNoPrec();
  3932.   Tree_nNoProp = Tree_mNoProp();
  3933. }
  3934.  
  3935. void Tree_CloseTree
  3936. # ifdef __STDC__
  3937. ()
  3938. # else
  3939. ()
  3940. # endif
  3941. {
  3942. }
  3943.  
  3944. static void xxExit
  3945. # ifdef __STDC__
  3946. ()
  3947. # else
  3948. ()
  3949. # endif
  3950. {
  3951.   IO_CloseIO();
  3952.   Exit(1L);
  3953. }
  3954.  
  3955. void BEGIN_Tree()
  3956. {
  3957.   static BOOLEAN has_been_called = FALSE;
  3958.  
  3959.   if (!has_been_called) {
  3960.     has_been_called = TRUE;
  3961.  
  3962.     BEGIN_IO();
  3963.     BEGIN_IO();
  3964.     BEGIN_Strings();
  3965.     BEGIN_StringMem();
  3966.     BEGIN_Idents();
  3967.     BEGIN_Texts();
  3968.     BEGIN_Sets();
  3969.     BEGIN_Relations();
  3970.     BEGIN_Positions();
  3971.     BEGIN_System();
  3972.     BEGIN_General();
  3973.     BEGIN_Memory();
  3974.     BEGIN_DynArray();
  3975.     BEGIN_IO();
  3976.     BEGIN_Layout();
  3977.     BEGIN_StringMem();
  3978.     BEGIN_Strings();
  3979.     BEGIN_Idents();
  3980.     BEGIN_Texts();
  3981.     BEGIN_Sets();
  3982.     BEGIN_Positions();
  3983.     BEGIN_DynArray();
  3984.     BEGIN_IO();
  3985.     BEGIN_Strings();
  3986.     BEGIN_StringMem();
  3987.     BEGIN_Idents();
  3988.     BEGIN_Texts();
  3989.     BEGIN_Sets();
  3990.     BEGIN_Relations();
  3991.     BEGIN_Positions();
  3992.     BEGIN_Relations();
  3993.     BEGIN_Errors();
  3994.  
  3995.     yyBlockList = NIL;
  3996.     Tree_yyPoolFreePtr = (ADDRESS)NIL;
  3997.     Tree_yyPoolMaxPtr = (ADDRESS)NIL;
  3998.     Tree_HeapUsed = 0;
  3999.     Tree_yyExit = xxExit;
  4000.     Tree_yyNodeSize.A[Tree_Classes] = sizeof(Tree_yClasses);
  4001.     Tree_yyNodeSize.A[Tree_NoClass] = sizeof(Tree_yNoClass);
  4002.     Tree_yyNodeSize.A[Tree_Class] = sizeof(Tree_yClass);
  4003.     Tree_yyNodeSize.A[Tree_Attributes] = sizeof(Tree_yAttributes);
  4004.     Tree_yyNodeSize.A[Tree_NoAttribute] = sizeof(Tree_yNoAttribute);
  4005.     Tree_yyNodeSize.A[Tree_AttrOrAction] = sizeof(Tree_yAttrOrAction);
  4006.     Tree_yyNodeSize.A[Tree_Child] = sizeof(Tree_yChild);
  4007.     Tree_yyNodeSize.A[Tree_Attribute] = sizeof(Tree_yAttribute);
  4008.     Tree_yyNodeSize.A[Tree_ActionPart] = sizeof(Tree_yActionPart);
  4009.     Tree_yyNodeSize.A[Tree_Codes] = sizeof(Tree_yCodes);
  4010.     Tree_yyNodeSize.A[Tree_Designators] = sizeof(Tree_yDesignators);
  4011.     Tree_yyNodeSize.A[Tree_NoDesignator] = sizeof(Tree_yNoDesignator);
  4012.     Tree_yyNodeSize.A[Tree_Designator] = sizeof(Tree_yDesignator);
  4013.     Tree_yyNodeSize.A[Tree_Ident] = sizeof(Tree_yIdent);
  4014.     Tree_yyNodeSize.A[Tree_Remote] = sizeof(Tree_yRemote);
  4015.     Tree_yyNodeSize.A[Tree_Any] = sizeof(Tree_yAny);
  4016.     Tree_yyNodeSize.A[Tree_Anys] = sizeof(Tree_yAnys);
  4017.     Tree_yyNodeSize.A[Tree_Layouts] = sizeof(Tree_yLayouts);
  4018.     Tree_yyNodeSize.A[Tree_NoLayout] = sizeof(Tree_yNoLayout);
  4019.     Tree_yyNodeSize.A[Tree_LayoutAny] = sizeof(Tree_yLayoutAny);
  4020.     Tree_yyNodeSize.A[Tree_Names] = sizeof(Tree_yNames);
  4021.     Tree_yyNodeSize.A[Tree_NoName] = sizeof(Tree_yNoName);
  4022.     Tree_yyNodeSize.A[Tree_Name] = sizeof(Tree_yName);
  4023.     Tree_yyNodeSize.A[Tree_Ag] = sizeof(Tree_yAg);
  4024.     Tree_yyNodeSize.A[Tree_Precs] = sizeof(Tree_yPrecs);
  4025.     Tree_yyNodeSize.A[Tree_NoPrec] = sizeof(Tree_yNoPrec);
  4026.     Tree_yyNodeSize.A[Tree_Prec] = sizeof(Tree_yPrec);
  4027.     Tree_yyNodeSize.A[Tree_LeftAssoc] = sizeof(Tree_yLeftAssoc);
  4028.     Tree_yyNodeSize.A[Tree_RightAssoc] = sizeof(Tree_yRightAssoc);
  4029.     Tree_yyNodeSize.A[Tree_NonAssoc] = sizeof(Tree_yNonAssoc);
  4030.     Tree_yyNodeSize.A[Tree_Actions] = sizeof(Tree_yActions);
  4031.     Tree_yyNodeSize.A[Tree_NoAction] = sizeof(Tree_yNoAction);
  4032.     Tree_yyNodeSize.A[Tree_Action] = sizeof(Tree_yAction);
  4033.     Tree_yyNodeSize.A[Tree_Assign] = sizeof(Tree_yAssign);
  4034.     Tree_yyNodeSize.A[Tree_Copy] = sizeof(Tree_yCopy);
  4035.     Tree_yyNodeSize.A[Tree_TargetCode] = sizeof(Tree_yTargetCode);
  4036.     Tree_yyNodeSize.A[Tree_Order] = sizeof(Tree_yOrder);
  4037.     Tree_yyNodeSize.A[Tree_Check] = sizeof(Tree_yCheck);
  4038.     Tree_yyNodeSize.A[Tree_Modules] = sizeof(Tree_yModules);
  4039.     Tree_yyNodeSize.A[Tree_NoModule] = sizeof(Tree_yNoModule);
  4040.     Tree_yyNodeSize.A[Tree_Module] = sizeof(Tree_yModule);
  4041.     Tree_yyNodeSize.A[Tree_Props] = sizeof(Tree_yProps);
  4042.     Tree_yyNodeSize.A[Tree_NoProp] = sizeof(Tree_yNoProp);
  4043.     Tree_yyNodeSize.A[Tree_Prop] = sizeof(Tree_yProp);
  4044.     Tree_yyNodeSize.A[Tree_Select] = sizeof(Tree_ySelect);
  4045.     Tree_yyNodeSize.A[Tree_Decls] = sizeof(Tree_yDecls);
  4046.     Tree_yyNodeSize.A[Tree_NoDecl] = sizeof(Tree_yNoDecl);
  4047.     Tree_yyNodeSize.A[Tree_Decl] = sizeof(Tree_yDecl);
  4048.     yyMaxSize = 0;
  4049.     for (yyi = 1; yyi <= 129; yyi += 1) {
  4050.       Tree_yyNodeSize.A[yyi] = (LONGINT)((BITSET)(Tree_yyNodeSize.A[yyi] + (CARDINAL)General_MaxAlign - 1) & General_AlignMasks.A[General_MaxAlign]);
  4051.       yyMaxSize = General_Max((LONGINT)Tree_yyNodeSize.A[yyi], (LONGINT)yyMaxSize);
  4052.     }
  4053.     yyTypeRange.A[Tree_Classes] = Tree_Class;
  4054.     yyTypeRange.A[Tree_NoClass] = Tree_NoClass;
  4055.     yyTypeRange.A[Tree_Class] = Tree_Class;
  4056.     yyTypeRange.A[Tree_Attributes] = Tree_ActionPart;
  4057.     yyTypeRange.A[Tree_NoAttribute] = Tree_NoAttribute;
  4058.     yyTypeRange.A[Tree_AttrOrAction] = Tree_ActionPart;
  4059.     yyTypeRange.A[Tree_Child] = Tree_Child;
  4060.     yyTypeRange.A[Tree_Attribute] = Tree_Attribute;
  4061.     yyTypeRange.A[Tree_ActionPart] = Tree_ActionPart;
  4062.     yyTypeRange.A[Tree_Codes] = Tree_Codes;
  4063.     yyTypeRange.A[Tree_Designators] = Tree_Anys;
  4064.     yyTypeRange.A[Tree_NoDesignator] = Tree_NoDesignator;
  4065.     yyTypeRange.A[Tree_Designator] = Tree_Designator;
  4066.     yyTypeRange.A[Tree_Ident] = Tree_Ident;
  4067.     yyTypeRange.A[Tree_Remote] = Tree_Remote;
  4068.     yyTypeRange.A[Tree_Any] = Tree_Any;
  4069.     yyTypeRange.A[Tree_Anys] = Tree_Anys;
  4070.     yyTypeRange.A[Tree_Layouts] = Tree_LayoutAny;
  4071.     yyTypeRange.A[Tree_NoLayout] = Tree_NoLayout;
  4072.     yyTypeRange.A[Tree_LayoutAny] = Tree_LayoutAny;
  4073.     yyTypeRange.A[Tree_Names] = Tree_Name;
  4074.     yyTypeRange.A[Tree_NoName] = Tree_NoName;
  4075.     yyTypeRange.A[Tree_Name] = Tree_Name;
  4076.     yyTypeRange.A[Tree_Ag] = Tree_Ag;
  4077.     yyTypeRange.A[Tree_Precs] = Tree_NonAssoc;
  4078.     yyTypeRange.A[Tree_NoPrec] = Tree_NoPrec;
  4079.     yyTypeRange.A[Tree_Prec] = Tree_NonAssoc;
  4080.     yyTypeRange.A[Tree_LeftAssoc] = Tree_LeftAssoc;
  4081.     yyTypeRange.A[Tree_RightAssoc] = Tree_RightAssoc;
  4082.     yyTypeRange.A[Tree_NonAssoc] = Tree_NonAssoc;
  4083.     yyTypeRange.A[Tree_Actions] = Tree_Check;
  4084.     yyTypeRange.A[Tree_NoAction] = Tree_NoAction;
  4085.     yyTypeRange.A[Tree_Action] = Tree_Check;
  4086.     yyTypeRange.A[Tree_Assign] = Tree_Assign;
  4087.     yyTypeRange.A[Tree_Copy] = Tree_Copy;
  4088.     yyTypeRange.A[Tree_TargetCode] = Tree_TargetCode;
  4089.     yyTypeRange.A[Tree_Order] = Tree_Order;
  4090.     yyTypeRange.A[Tree_Check] = Tree_Check;
  4091.     yyTypeRange.A[Tree_Modules] = Tree_Module;
  4092.     yyTypeRange.A[Tree_NoModule] = Tree_NoModule;
  4093.     yyTypeRange.A[Tree_Module] = Tree_Module;
  4094.     yyTypeRange.A[Tree_Props] = Tree_Select;
  4095.     yyTypeRange.A[Tree_NoProp] = Tree_NoProp;
  4096.     yyTypeRange.A[Tree_Prop] = Tree_Prop;
  4097.     yyTypeRange.A[Tree_Select] = Tree_Select;
  4098.     yyTypeRange.A[Tree_Decls] = Tree_Decl;
  4099.     yyTypeRange.A[Tree_NoDecl] = Tree_NoDecl;
  4100.     yyTypeRange.A[Tree_Decl] = Tree_Decl;
  4101.     Tree_BeginTree();
  4102.   }
  4103. }
  4104.